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

third_party/WebKit/Source/platform/scheduler/base/task_queue_manager_unittest.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 "platform/scheduler/base/task_queue_manager.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 42 matching lines @@
   using TaskQueueManager::NextTaskDelay;
 };
 
 class MessageLoopTaskRunner : public TaskQueueManagerDelegateForTest {
  public:
   static scoped_refptr<MessageLoopTaskRunner> Create(
       std::unique_ptr<base::TickClock> tick_clock) {
     return make_scoped_refptr(new MessageLoopTaskRunner(std::move(tick_clock)));
   }
 
-  // NestableTaskRunner implementation.
+  // TaskQueueManagerDelegateForTest:
   bool IsNested() const override {
-    return base::MessageLoop::current()->IsNested();
+    DCHECK(RunsTasksOnCurrentThread());
+    return base::RunLoop::IsNestedOnCurrentThread();
   }
 
-  void AddNestingObserver(
-      base::MessageLoop::NestingObserver* observer) override {
-    base::MessageLoop::current()->AddNestingObserver(observer);
+  void AddNestingObserver(base::RunLoop::NestingObserver* observer) override {
+    base::RunLoop::AddNestingObserverOnCurrentThread(observer);
   }
 
   void RemoveNestingObserver(
-      base::MessageLoop::NestingObserver* observer) override {
-    base::MessageLoop::current()->RemoveNestingObserver(observer);
+      base::RunLoop::NestingObserver* observer) override {
+    base::RunLoop::RemoveNestingObserverOnCurrentThread(observer);
   }
 
  private:
   explicit MessageLoopTaskRunner(std::unique_ptr<base::TickClock> tick_clock)
       : TaskQueueManagerDelegateForTest(base::ThreadTaskRunnerHandle::Get(),
                                         std::move(tick_clock)) {}
   ~MessageLoopTaskRunner() override {}
 };
 
 class TaskQueueManagerTest : public testing::Test {
@@ skipping 1158 matching lines @@
   runners_[1]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order),
                                delay2);
 
   now_src_->Advance(delay1 * 2);
   test_task_runner_->RunUntilIdle();
 
   EXPECT_THAT(run_order, ElementsAre(2, 1));
 }
 
 void CheckIsNested(bool* is_nested) {
-  *is_nested = base::MessageLoop::current()->IsNested();
+  *is_nested = base::RunLoop::IsNestedOnCurrentThread();
 }
 
 void PostAndQuitFromNestedRunloop(base::RunLoop* run_loop,
                                   base::SingleThreadTaskRunner* runner,
                                   bool* was_nested) {
   base::MessageLoop::ScopedNestableTaskAllower allow(
       base::MessageLoop::current());
   runner->PostTask(FROM_HERE, run_loop->QuitClosure());
   runner->PostTask(FROM_HERE, base::Bind(&CheckIsNested, was_nested));
   run_loop->Run();
@@ skipping 1643 matching lines @@
   manager_->RegisterTimeDomain(domain.get());
   runners_[0]->SetTimeDomain(domain.get());
 
   // Tidy up.
   runners_[0]->UnregisterTaskQueue();
   manager_->UnregisterTimeDomain(domain.get());
 }
 
 }  // namespace scheduler
 }  // namespace blink