Rename TaskRunner::RunsTasksOnCurrentThread() in //components

components/gcm_driver/fake_gcm_client.cc

 // Copyright 2014 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/gcm_driver/fake_gcm_client.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 68 matching lines @@
     const scoped_refptr<net::URLRequestContextGetter>&
         url_request_context_getter,
     std::unique_ptr<Encryptor> encryptor,
     Delegate* delegate) {
   product_category_for_subtypes_ =
       chrome_build_info.product_category_for_subtypes;
   delegate_ = delegate;
 }
 
 void FakeGCMClient::Start(StartMode start_mode) {
-  DCHECK(io_thread_->RunsTasksOnCurrentThread());
+  DCHECK(io_thread_->RunsTasksInCurrentSequence());
 
   if (started_)
     return;
 
   if (start_mode == IMMEDIATE_START)
     start_mode_ = IMMEDIATE_START;
   if (start_mode_ == DELAYED_START ||
       start_mode_overridding_ == FORCE_TO_ALWAYS_DELAY_START_GCM) {
     return;
   }
 
   DoStart();
 }
 
 void FakeGCMClient::DoStart() {
   started_ = true;
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&FakeGCMClient::Started, weak_ptr_factory_.GetWeakPtr()));
 }
 
 void FakeGCMClient::Stop() {
-  DCHECK(io_thread_->RunsTasksOnCurrentThread());
+  DCHECK(io_thread_->RunsTasksInCurrentSequence());
   started_ = false;
   delegate_->OnDisconnected();
 }
 
 void FakeGCMClient::Register(
     const linked_ptr<RegistrationInfo>& registration_info) {
-  DCHECK(io_thread_->RunsTasksOnCurrentThread());
+  DCHECK(io_thread_->RunsTasksInCurrentSequence());
 
   std::string registration_id;
 
   GCMRegistrationInfo* gcm_registration_info =
       GCMRegistrationInfo::FromRegistrationInfo(registration_info.get());
   if (gcm_registration_info) {
     registration_id = GenerateGCMRegistrationID(
         gcm_registration_info->sender_ids);
   }
 
@@ skipping 12 matching lines @@
 }
 
 bool FakeGCMClient::ValidateRegistration(
     const linked_ptr<RegistrationInfo>& registration_info,
     const std::string& registration_id) {
   return true;
 }
 
 void FakeGCMClient::Unregister(
     const linked_ptr<RegistrationInfo>& registration_info) {
-  DCHECK(io_thread_->RunsTasksOnCurrentThread());
+  DCHECK(io_thread_->RunsTasksInCurrentSequence());
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&FakeGCMClient::UnregisterFinished,
                             weak_ptr_factory_.GetWeakPtr(), registration_info));
 }
 
 void FakeGCMClient::Send(const std::string& app_id,
                          const std::string& receiver_id,
                          const OutgoingMessage& message) {
-  DCHECK(io_thread_->RunsTasksOnCurrentThread());
+  DCHECK(io_thread_->RunsTasksInCurrentSequence());
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&FakeGCMClient::SendFinished,
                             weak_ptr_factory_.GetWeakPtr(), app_id, message));
 }
 
 void FakeGCMClient::RecordDecryptionFailure(
     const std::string& app_id,
     GCMEncryptionProvider::DecryptionResult result) {
   recorder_.RecordDecryptionFailure(app_id, result);
@@ skipping 56 matching lines @@
 }
 
 void FakeGCMClient::AddHeartbeatInterval(const std::string& scope,
                                          int interval_ms) {
 }
 
 void FakeGCMClient::RemoveHeartbeatInterval(const std::string& scope) {
 }
 
 void FakeGCMClient::PerformDelayedStart() {
-  DCHECK(ui_thread_->RunsTasksOnCurrentThread());
+  DCHECK(ui_thread_->RunsTasksInCurrentSequence());
 
   io_thread_->PostTask(
       FROM_HERE,
       base::Bind(&FakeGCMClient::DoStart, weak_ptr_factory_.GetWeakPtr()));
 }
 
 void FakeGCMClient::ReceiveMessage(const std::string& app_id,
                                    const IncomingMessage& message) {
-  DCHECK(ui_thread_->RunsTasksOnCurrentThread());
+  DCHECK(ui_thread_->RunsTasksInCurrentSequence());
 
   io_thread_->PostTask(
       FROM_HERE,
       base::Bind(&FakeGCMClient::MessageReceived,
                  weak_ptr_factory_.GetWeakPtr(),
                  app_id,
                  message));
 }
 
 void FakeGCMClient::DeleteMessages(const std::string& app_id) {
-  DCHECK(ui_thread_->RunsTasksOnCurrentThread());
+  DCHECK(ui_thread_->RunsTasksInCurrentSequence());
 
   io_thread_->PostTask(
       FROM_HERE,
       base::Bind(&FakeGCMClient::MessagesDeleted,
                  weak_ptr_factory_.GetWeakPtr(),
                  app_id));
 }
 
 void FakeGCMClient::Started() {
   delegate_->OnGCMReady(std::vector<AccountMapping>(), base::Time());
@@ skipping 56 matching lines @@
     delegate_->OnMessageSendError(app_id, send_error_details);
 }
 
 void FakeGCMClient::SendAcknowledgement(const std::string& app_id,
                                         const std::string& message_id) {
   if (delegate_)
     delegate_->OnSendAcknowledged(app_id, message_id);
 }
 
 }  // namespace gcm