Rename TaskRunner::RunsTasksOnCurrentThread() in //chrome

chrome/browser/notifications/notification_platform_bridge_linux.cc

 // Copyright 2017 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 "chrome/browser/notifications/notification_platform_bridge_linux.h"
 
 #include <algorithm>
 #include <memory>
 #include <set>
 #include <unordered_map>
@@ skipping 320 matching lines @@
                const content::NotificationSource& source,
                const content::NotificationDetails& details) override {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     DCHECK_EQ(chrome::NOTIFICATION_APP_TERMINATING, type);
     // The browser process is about to exit.  Post the CleanUp() task
     // while we still can.
     CleanUp();
   }
 
   void PostTaskToUiThread(base::OnceClosure closure) const {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     bool success = content::BrowserThread::PostTask(
         content::BrowserThread::UI, FROM_HERE, std::move(closure));
     DCHECK(success);
   }
 
   void PostTaskToTaskRunnerThread(base::OnceClosure closure) const {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     DCHECK(task_runner_);
     bool success = task_runner_->PostTask(FROM_HERE, std::move(closure));
     DCHECK(success);
   }
 
   // Sets up the D-Bus connection.
   void InitOnTaskRunner() {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     // |bus_| may be non-null in unit testing where a fake bus is used.
     if (!bus_) {
       dbus::Bus::Options bus_options;
       bus_options.bus_type = dbus::Bus::SESSION;
       bus_options.connection_type = dbus::Bus::PRIVATE;
       bus_options.dbus_task_runner = task_runner_;
       bus_ = make_scoped_refptr(new dbus::Bus(bus_options));
     }
 
     notification_proxy_ =
@@ skipping 55 matching lines @@
                    this));
     notification_proxy_->ConnectToSignal(
         kFreedesktopNotificationsName, kSignalNotificationClosed,
         base::Bind(&NotificationPlatformBridgeLinuxImpl::OnNotificationClosed,
                    this),
         base::Bind(&NotificationPlatformBridgeLinuxImpl::OnSignalConnected,
                    this));
   }
 
   void CleanUpOnTaskRunner() {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     if (bus_)
       bus_->ShutdownAndBlock();
     bus_ = nullptr;
     notification_proxy_ = nullptr;
     notifications_.clear();
   }
 
   // Makes the "Notify" call to D-Bus.
   void DisplayOnTaskRunner(NotificationCommon::Type notification_type,
                            const std::string& notification_id,
                            const std::string& profile_id,
                            bool is_incognito,
                            std::unique_ptr<Notification> notification) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     NotificationData* data =
         FindNotificationData(notification_id, profile_id, is_incognito);
     if (data) {
       // Update an existing notification.
       data->notification_type = notification_type;
       data->resource_files.clear();
     } else {
       // Send the notification for the first time.
       data =
           new NotificationData(notification_type, notification_id, profile_id,
@@ skipping 103 matching lines @@
     }
     if (!data->dbus_id) {
       // There was some sort of error with creating the notification.
       notifications_.erase(data);
     }
   }
 
   // Makes the "CloseNotification" call to D-Bus.
   void CloseOnTaskRunner(const std::string& profile_id,
                          const std::string& notification_id) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     std::vector<NotificationData*> to_erase;
     for (const auto& pair : notifications_) {
       NotificationData* data = pair.first;
       if (data->notification_id == notification_id &&
           data->profile_id == profile_id) {
         dbus::MethodCall method_call(kFreedesktopNotificationsName,
                                      kMethodCloseNotification);
         dbus::MessageWriter writer(&method_call);
         writer.AppendUint32(data->dbus_id);
         notification_proxy_->CallMethodAndBlock(
             &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT);
         to_erase.push_back(data);
       }
     }
     for (NotificationData* data : to_erase)
       notifications_.erase(data);
   }
 
   void GetDisplayedOnTaskRunner(
       const std::string& profile_id,
       bool incognito,
       const GetDisplayedNotificationsCallback& callback) const {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     auto displayed = base::MakeUnique<std::set<std::string>>();
     for (const auto& pair : notifications_) {
       NotificationData* data = pair.first;
       if (data->profile_id == profile_id && data->is_incognito == incognito)
         displayed->insert(data->notification_id);
     }
     PostTaskToUiThread(base::BindOnce(callback, std::move(displayed), true));
   }
 
   NotificationData* FindNotificationData(const std::string& notification_id,
                                          const std::string& profile_id,
                                          bool is_incognito) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     for (const auto& pair : notifications_) {
       NotificationData* data = pair.first;
       if (data->notification_id == notification_id &&
           data->profile_id == profile_id &&
           data->is_incognito == is_incognito) {
         return data;
       }
     }
 
     return nullptr;
   }
 
   NotificationData* FindNotificationDataWithDBusId(uint32_t dbus_id) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     DCHECK(dbus_id);
     for (const auto& pair : notifications_) {
       NotificationData* data = pair.first;
       if (data->dbus_id == dbus_id)
         return data;
     }
 
     return nullptr;
   }
 
   void ForwardNotificationOperation(NotificationData* data,
                                     NotificationCommon::Operation operation,
                                     int action_index) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     PostTaskToUiThread(base::BindOnce(
         ForwardNotificationOperationOnUiThread, operation,
         data->notification_type, data->origin_url.spec(), data->notification_id,
         action_index, data->profile_id, data->is_incognito));
   }
 
   void OnActionInvoked(dbus::Signal* signal) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     dbus::MessageReader reader(signal);
     uint32_t dbus_id;
     if (!reader.PopUint32(&dbus_id) || !dbus_id)
       return;
     std::string action;
     if (!reader.PopString(&action))
       return;
 
     NotificationData* data = FindNotificationDataWithDBusId(dbus_id);
     if (!data)
@@ skipping 10 matching lines @@
       size_t n_buttons = data->action_end - data->action_start;
       size_t id_zero_based = id - data->action_start;
       if (id_zero_based >= n_buttons)
         return;
       ForwardNotificationOperation(data, NotificationCommon::CLICK,
                                    id_zero_based);
     }
   }
 
   void OnNotificationClosed(dbus::Signal* signal) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     dbus::MessageReader reader(signal);
     uint32_t dbus_id;
     if (!reader.PopUint32(&dbus_id) || !dbus_id)
       return;
 
     NotificationData* data = FindNotificationDataWithDBusId(dbus_id);
     if (!data)
       return;
 
     ForwardNotificationOperation(data, NotificationCommon::CLOSE, -1);
     notifications_.erase(data);
   }
 
   // Called once the connection has been set up (or not).  |success|
   // indicates the connection is ready to use.
   void OnConnectionInitializationFinishedOnUiThread(bool success) {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     connected_ = success;
     for (auto& callback : on_connected_callbacks_)
       std::move(callback).Run(success);
     on_connected_callbacks_.clear();
     if (!success)
       CleanUp();
   }
 
   void OnConnectionInitializationFinishedOnTaskRunner(
       ConnectionInitializationStatusCode status) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     UMA_HISTOGRAM_ENUMERATION(
         "Notifications.Linux.BridgeInitializationStatus",
         static_cast<int>(status),
         static_cast<int>(ConnectionInitializationStatusCode::NUM_ITEMS));
     PostTaskToUiThread(base::BindOnce(
         &NotificationPlatformBridgeLinuxImpl::
             OnConnectionInitializationFinishedOnUiThread,
         this, status == ConnectionInitializationStatusCode::SUCCESS));
   }
 
   void OnSignalConnected(const std::string& interface_name,
                          const std::string& signal_name,
                          bool success) {
-    DCHECK(task_runner_->RunsTasksOnCurrentThread());
+    DCHECK(task_runner_->RunsTasksInCurrentSequence());
     if (!success) {
       OnConnectionInitializationFinishedOnTaskRunner(
           ConnectionInitializationStatusCode::COULD_NOT_CONNECT_TO_SIGNALS);
       return;
     }
     connected_signals_barrier_.Run();
   }
 
   void RecordMetricsForCapabilities() {
     // Histogram macros must be called with the same name for each
@@ skipping 98 matching lines @@
 }
 
 void NotificationPlatformBridgeLinux::SetReadyCallback(
     NotificationBridgeReadyCallback callback) {
   impl_->SetReadyCallback(std::move(callback));
 }
 
 void NotificationPlatformBridgeLinux::CleanUp() {
   impl_->CleanUp();
 }