Make nesting/running states a RunLoop rather than a MessageLoop concept.

third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.h

 // 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.
 
 #ifndef THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_MANAGER_H_
 #define THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_MANAGER_H_
 
 #include <map>
 
 #include "base/atomic_sequence_num.h"
 #include "base/cancelable_callback.h"
 #include "base/debug/task_annotator.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/pending_task.h"
+#include "base/run_loop.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_checker.h"
 #include "platform/scheduler/base/enqueue_order.h"
 #include "platform/scheduler/base/moveable_auto_lock.h"
 #include "platform/scheduler/base/task_queue_impl.h"
 #include "platform/scheduler/base/task_queue_selector.h"
 
 namespace base {
 namespace trace_event {
 class ConvertableToTraceFormat;
@@ skipping 19 matching lines @@
 // 1. Incoming task queue. Tasks that are posted get immediately appended here.
 //    When a task is appended into an empty incoming queue, the task manager
 //    work function (DoWork) is scheduled to run on the main task runner.
 //
 // 2. Work queue. If a work queue is empty when DoWork() is entered, tasks from
 //    the incoming task queue (if any) are moved here. The work queues are
 //    registered with the selector as input to the scheduling decision.
 //
 class BLINK_PLATFORM_EXPORT TaskQueueManager
     : public internal::TaskQueueSelector::Observer,
-      public base::MessageLoop::NestingObserver {
+      public base::RunLoop::NestingObserver {
  public:
   // Create a task queue manager where |delegate| identifies the thread
   // on which where the tasks are  eventually run. Category strings must have
   // application lifetime (statics or literals). They may not include " chars.
   TaskQueueManager(scoped_refptr<TaskQueueManagerDelegate> delegate,
                    const char* tracing_category,
                    const char* disabled_by_default_tracing_category,
                    const char* disabled_by_default_verbose_tracing_category);
   ~TaskQueueManager() override;
 
@@ skipping 162 matching lines @@
   };
 
   // Unregisters a TaskQueue previously created by |NewTaskQueue()|.
   void UnregisterTaskQueue(scoped_refptr<internal::TaskQueueImpl> task_queue);
 
   // TaskQueueSelector::Observer implementation:
   void OnTaskQueueEnabled(internal::TaskQueueImpl* queue) override;
   void OnTriedToSelectBlockedWorkQueue(
       internal::WorkQueue* work_queue) override;
 
-  // base::MessageLoop::NestingObserver implementation:
-  void OnBeginNestedMessageLoop() override;
+  // base::RunLoop::NestingObserver implementation:
+  void OnBeginNestedRunLoop() override;
 
   // Called by the task queue to register a new pending task.
   void DidQueueTask(const internal::TaskQueueImpl::Task& pending_task);
 
   // Use the selector to choose a pending task and run it.
   void DoWork(bool delayed);
 
   // Post a DoWork continuation if |next_delay| is not empty.
   void PostDoWorkContinuationLocked(base::Optional<NextTaskDelay> next_delay,
                                     LazyNow* lazy_now,
@@ skipping 131 matching lines @@
   scoped_refptr<DeletionSentinel> deletion_sentinel_;
   base::WeakPtrFactory<TaskQueueManager> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskQueueManager);
 };
 
 }  // namespace scheduler
 }  // namespace blink
 
 #endif  // THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_BASE_TASK_QUEUE_MANAGER_H_