[MessageLoop] Rename IncomingTaskQueue to PendingTaskQueue

Rename-only follow-up to https://chromium-review.googlesource.com/c/chromium/src/+/1088762
(made that CL's diff simpler to rename independently).

R=kylechar@chromium.org

Bug: 860252, 708584
Change-Id: I3c5e2187b05a4966f7de718fe81c18b09d4e47ec
Reviewed-on: https://chromium-review.googlesource.com/1153458
Commit-Queue: Gabriel Charette <gab@chromium.org>
Reviewed-by: kylechar <kylechar@chromium.org>
Cr-Commit-Position: refs/heads/master@{#579077}

base/BUILD.gn

@@ -550,8 +550,6 @@ jumbo_component("base") {
     "memory/weak_ptr.h",
     "memory/writable_shared_memory_region.cc",
     "memory/writable_shared_memory_region.h",
-    "message_loop/incoming_task_queue.cc",
-    "message_loop/incoming_task_queue.h",
     "message_loop/message_loop.cc",
     "message_loop/message_loop.h",
     "message_loop/message_loop_current.cc",
@@ -574,6 +572,8 @@ jumbo_component("base") {
     "message_loop/message_pump_mac.mm",
     "message_loop/message_pump_win.cc",
     "message_loop/message_pump_win.h",
+    "message_loop/pending_task_queue.cc",
+    "message_loop/pending_task_queue.h",
     "message_loop/sequenced_task_source.h",
     "message_loop/timer_slack.h",
     "metrics/bucket_ranges.cc",

base/message_loop/message_loop.h

@@ -14,9 +14,9 @@
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/scoped_refptr.h"
-#include "base/message_loop/incoming_task_queue.h"
 #include "base/message_loop/message_loop_current.h"
 #include "base/message_loop/message_pump.h"
+#include "base/message_loop/pending_task_queue.h"
 #include "base/message_loop/timer_slack.h"
 #include "base/observer_list.h"
 #include "base/pending_task.h"
@@ -318,7 +318,7 @@ class BASE_EXPORT MessageLoop : public MessagePump::Delegate,
   // |underlying_task_runner_|. TODO(gab): Make this customizable.
   SequencedTaskSource* const sequenced_task_source_;
 
-  internal::IncomingTaskQueue pending_task_queue_;
+  internal::PendingTaskQueue pending_task_queue_;
 
   // The task runner exposed by this message loop.
   scoped_refptr<SingleThreadTaskRunner> task_runner_;

base/message_loop/message_loop_task_runner.h

@@ -20,9 +20,8 @@ namespace base {
 namespace internal {
 
 // A SingleThreadTaskRunner which receives and queues tasks destined to its
-// owning MessageLoop (vending them back to its IncomingTaskQueue over the
-// SequencedTaskSource interface). It does not manage delays (i.e. tasks
-// returned by TakeTask() might have a non-zero delay).
+// owning MessageLoop. It does not manage delays (i.e. tasks returned by
+// TakeTask() might have a non-zero delay).
 class BASE_EXPORT MessageLoopTaskRunner : public SingleThreadTaskRunner,
                                           public SequencedTaskSource {
  public:

base/message_loop/incoming_task_queue.cc → base/message_loop/pending_task_queue.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "base/message_loop/incoming_task_queue.h"
+#include "base/message_loop/pending_task_queue.h"
 
 #include <utility>
 
@@ -13,25 +13,25 @@
 namespace base {
 namespace internal {
 
-IncomingTaskQueue::IncomingTaskQueue() = default;
+PendingTaskQueue::PendingTaskQueue() = default;
 
-IncomingTaskQueue::~IncomingTaskQueue() = default;
+PendingTaskQueue::~PendingTaskQueue() = default;
 
-void IncomingTaskQueue::ReportMetricsOnIdle() const {
+void PendingTaskQueue::ReportMetricsOnIdle() const {
   UMA_HISTOGRAM_COUNTS_1M(
       "MessageLoop.DelayedTaskQueueForUI.PendingTasksCountOnIdle",
       delayed_tasks_.Size());
 }
 
-IncomingTaskQueue::DelayedQueue::DelayedQueue() {
+PendingTaskQueue::DelayedQueue::DelayedQueue() {
   // The constructing sequence is not necessarily the running sequence, e.g. in
   // the case of a MessageLoop created unbound.
   DETACH_FROM_SEQUENCE(sequence_checker_);
 }
 
-IncomingTaskQueue::DelayedQueue::~DelayedQueue() = default;
+PendingTaskQueue::DelayedQueue::~DelayedQueue() = default;
 
-void IncomingTaskQueue::DelayedQueue::Push(PendingTask pending_task) {
+void PendingTaskQueue::DelayedQueue::Push(PendingTask pending_task) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (pending_task.is_high_res)
@@ -40,13 +40,13 @@ void IncomingTaskQueue::DelayedQueue::Push(PendingTask pending_task) {
   queue_.push(std::move(pending_task));
 }
 
-const PendingTask& IncomingTaskQueue::DelayedQueue::Peek() {
+const PendingTask& PendingTaskQueue::DelayedQueue::Peek() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!queue_.empty());
   return queue_.top();
 }
 
-PendingTask IncomingTaskQueue::DelayedQueue::Pop() {
+PendingTask PendingTaskQueue::DelayedQueue::Pop() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!queue_.empty());
   PendingTask delayed_task = std::move(const_cast<PendingTask&>(queue_.top()));
@@ -59,7 +59,7 @@ PendingTask IncomingTaskQueue::DelayedQueue::Pop() {
   return delayed_task;
 }
 
-bool IncomingTaskQueue::DelayedQueue::HasTasks() {
+bool PendingTaskQueue::DelayedQueue::HasTasks() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   // TODO(robliao): The other queues don't check for IsCancelled(). Should they?
   while (!queue_.empty() && Peek().task.IsCancelled())
@@ -68,37 +68,37 @@ bool IncomingTaskQueue::DelayedQueue::HasTasks() {
   return !queue_.empty();
 }
 
-void IncomingTaskQueue::DelayedQueue::Clear() {
+void PendingTaskQueue::DelayedQueue::Clear() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   while (!queue_.empty())
     Pop();
 }
 
-size_t IncomingTaskQueue::DelayedQueue::Size() const {
+size_t PendingTaskQueue::DelayedQueue::Size() const {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return queue_.size();
 }
 
-IncomingTaskQueue::DeferredQueue::DeferredQueue() {
+PendingTaskQueue::DeferredQueue::DeferredQueue() {
   // The constructing sequence is not necessarily the running sequence, e.g. in
   // the case of a MessageLoop created unbound.
   DETACH_FROM_SEQUENCE(sequence_checker_);
 }
 
-IncomingTaskQueue::DeferredQueue::~DeferredQueue() = default;
+PendingTaskQueue::DeferredQueue::~DeferredQueue() = default;
 
-void IncomingTaskQueue::DeferredQueue::Push(PendingTask pending_task) {
+void PendingTaskQueue::DeferredQueue::Push(PendingTask pending_task) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   queue_.push(std::move(pending_task));
 }
 
-const PendingTask& IncomingTaskQueue::DeferredQueue::Peek() {
+const PendingTask& PendingTaskQueue::DeferredQueue::Peek() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!queue_.empty());
   return queue_.front();
 }
 
-PendingTask IncomingTaskQueue::DeferredQueue::Pop() {
+PendingTask PendingTaskQueue::DeferredQueue::Pop() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!queue_.empty());
   PendingTask deferred_task = std::move(queue_.front());
@@ -106,12 +106,12 @@ PendingTask IncomingTaskQueue::DeferredQueue::Pop() {
   return deferred_task;
 }
 
-bool IncomingTaskQueue::DeferredQueue::HasTasks() {
+bool PendingTaskQueue::DeferredQueue::HasTasks() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   return !queue_.empty();
 }
 
-void IncomingTaskQueue::DeferredQueue::Clear() {
+void PendingTaskQueue::DeferredQueue::Clear() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   while (!queue_.empty())
     Pop();

base/message_loop/incoming_task_queue.h → base/message_loop/pending_task_queue.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef BASE_MESSAGE_LOOP_INCOMING_TASK_QUEUE_H_
-#define BASE_MESSAGE_LOOP_INCOMING_TASK_QUEUE_H_
+#ifndef BASE_MESSAGE_LOOP_PENDING_TASK_QUEUE_H_
+#define BASE_MESSAGE_LOOP_PENDING_TASK_QUEUE_H_
 
 #include "base/macros.h"
 #include "base/pending_task.h"
@@ -16,7 +16,7 @@ namespace internal {
 // DeferredQueue.
 // TODO(gab): Rename to PendingTaskQueue after landing
 // https://crrev.com/1088762.
-class IncomingTaskQueue {
+class PendingTaskQueue {
  public:
   // Provides a read-write task queue.
   class Queue {
@@ -43,8 +43,8 @@ class IncomingTaskQueue {
     DISALLOW_COPY_AND_ASSIGN(Queue);
   };
 
-  IncomingTaskQueue();
-  ~IncomingTaskQueue();
+  PendingTaskQueue();
+  ~PendingTaskQueue();
 
   Queue& delayed_tasks() { return delayed_tasks_; }
 
@@ -116,10 +116,10 @@ class IncomingTaskQueue {
   DelayedQueue delayed_tasks_;
   DeferredQueue deferred_tasks_;
 
-  DISALLOW_COPY_AND_ASSIGN(IncomingTaskQueue);
+  DISALLOW_COPY_AND_ASSIGN(PendingTaskQueue);
 };
 
 }  // namespace internal
 }  // namespace base
 
-#endif  // BASE_MESSAGE_LOOP_INCOMING_TASK_QUEUE_H_
+#endif  // BASE_MESSAGE_LOOP_PENDING_TASK_QUEUE_H_

base/test/scoped_task_environment.cc

@@ -190,8 +190,8 @@ void ScopedTaskEnvironment::RunUntilIdle() {
   //       if (task_tracker_->HasIncompleteTasks())
   //         PlatformThread::Sleep(TimeDelta::FromMilliSeconds(1));
   //     }
-  // Challenge: HasMainThreadTasks() requires support for proper
-  // IncomingTaskQueue::IsIdleForTesting() (check all queues).
+  // Update: This can likely be done now that MessageLoop::IsIdleForTesting()
+  // checks all queues.
   //
   // Other than that it works because once |task_tracker_->HasIncompleteTasks()|
   // is false we know for sure that the only thing that can make it true is a