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

base/run_loop_unittest.cc

Index: base/run_loop_unittest.cc
diff --git a/base/run_loop_unittest.cc b/base/run_loop_unittest.cc
index a87ced09885f041a148f04c639620fec4e58aea3..491719a7fdd3fd9a74fe928d9b746e85534b8d5e 100644
--- a/base/run_loop_unittest.cc
+++ b/base/run_loop_unittest.cc
@@ -11,6 +11,7 @@
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
@@ -62,12 +63,12 @@ class RunLoopTest : public testing::Test {
 }  // namespace
 
 TEST_F(RunLoopTest, QuitWhenIdle) {
-  message_loop_.task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       Bind(&QuitWhenIdleTask, Unretained(&run_loop_), Unretained(&counter_)));
-  message_loop_.task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&ShouldRunTask, Unretained(&counter_)));
-  message_loop_.task_runner()->PostDelayedTask(
+  ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, Bind(&ShouldNotRunTask), TimeDelta::FromDays(1));
 
   run_loop_.Run();
@@ -75,14 +76,14 @@ TEST_F(RunLoopTest, QuitWhenIdle) {
 }
 
 TEST_F(RunLoopTest, QuitWhenIdleNestedLoop) {
-  message_loop_.task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&RunNestedLoopTask, Unretained(&counter_)));
-  message_loop_.task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       Bind(&QuitWhenIdleTask, Unretained(&run_loop_), Unretained(&counter_)));
-  message_loop_.task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&ShouldRunTask, Unretained(&counter_)));
-  message_loop_.task_runner()->PostDelayedTask(
+  ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, Bind(&ShouldNotRunTask), TimeDelta::FromDays(1));
 
   run_loop_.Run();
@@ -90,11 +91,11 @@ TEST_F(RunLoopTest, QuitWhenIdleNestedLoop) {
 }
 
 TEST_F(RunLoopTest, QuitWhenIdleClosure) {
-  message_loop_.task_runner()->PostTask(FROM_HERE,
-                                        run_loop_.QuitWhenIdleClosure());
-  message_loop_.task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                          run_loop_.QuitWhenIdleClosure());
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&ShouldRunTask, Unretained(&counter_)));
-  message_loop_.task_runner()->PostDelayedTask(
+  ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, Bind(&ShouldNotRunTask), TimeDelta::FromDays(1));
 
   run_loop_.Run();
@@ -113,4 +114,94 @@ TEST_F(RunLoopTest, QuitWhenIdleClosureAfterRunLoopScope) {
   quit_when_idle_closure.Run();
 }
 
+TEST_F(RunLoopTest, IsRunningOnCurrentThread) {
+  EXPECT_FALSE(RunLoop::IsRunningOnCurrentThread());
+  ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      Bind([]() { EXPECT_TRUE(RunLoop::IsRunningOnCurrentThread()); }));
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, run_loop_.QuitClosure());
+  run_loop_.Run();
+}
+
+TEST_F(RunLoopTest, IsNestedOnCurrentThread) {
+  EXPECT_FALSE(RunLoop::IsNestedOnCurrentThread());
+
+  ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, Bind([]() {
+        EXPECT_FALSE(RunLoop::IsNestedOnCurrentThread());
+
+        RunLoop nested_run_loop;
+
+        ThreadTaskRunnerHandle::Get()->PostTask(
+            FROM_HERE,
+            Bind([]() { EXPECT_TRUE(RunLoop::IsNestedOnCurrentThread()); }));
+        ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                nested_run_loop.QuitClosure());
+
+        EXPECT_FALSE(RunLoop::IsNestedOnCurrentThread());
+        MessageLoop::ScopedNestableTaskAllower allower(MessageLoop::current());
+        nested_run_loop.Run();
+        EXPECT_FALSE(RunLoop::IsNestedOnCurrentThread());
+      }));
+
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, run_loop_.QuitClosure());
+  run_loop_.Run();
+}
+
+// A NestingObserver that tracks the number of nested message loop starts it
+// has seen.
+class TestNestingObserver : public RunLoop::NestingObserver {
+ public:
+  TestNestingObserver() = default;
+
+  // RunLoop::NestingObserver:
+  MOCK_METHOD0(OnBeginNestedMessageLoop, void());
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestNestingObserver);
+};
+
+TEST_F(RunLoopTest, NestingObservers) {
+  EXPECT_TRUE(RunLoop::IsNestingAllowedOnCurrentThread());
+
+  testing::StrictMock<TestNestingObserver> nesting_observer;
+
+  RunLoop::AddNestingObserverOnCurrentThread(&nesting_observer);
+
+  const RepeatingClosure run_nested_loop = Bind([]() {
+    RunLoop nested_run_loop;
+    ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, Bind([]() {
+          EXPECT_TRUE(RunLoop::IsNestingAllowedOnCurrentThread());
+        }));
+    ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                            nested_run_loop.QuitClosure());
+    MessageLoop::ScopedNestableTaskAllower allower(MessageLoop::current());
+    nested_run_loop.Run();
+  });
+
+  // Generate a stack of nested RunLoops, an OnBeginNestedMessageLoop() is
+  // expected when beginning each nesting depth.
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, run_nested_loop);
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, run_nested_loop);
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, run_loop_.QuitClosure());
+
+  // The nesting observer shouldn't have been invoked before running the loop.
+  testing::Mock::VerifyAndClear(&nesting_observer);
+  EXPECT_CALL(nesting_observer, OnBeginNestedMessageLoop()).Times(2);
+  run_loop_.Run();
+}
+
+TEST_F(RunLoopTest, DisallowWaitingDeathTest) {
+  EXPECT_TRUE(RunLoop::IsNestingAllowedOnCurrentThread());
+  RunLoop::DisallowNestingOnCurrentThread();
+  EXPECT_FALSE(RunLoop::IsNestingAllowedOnCurrentThread());
+
+  ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, Bind([]() {
+                                            RunLoop nested_run_loop;
+                                            nested_run_loop.RunUntilIdle();
+                                          }));
+  EXPECT_DEATH({ run_loop_.RunUntilIdle(); }, "Check failed");
+}
+
 }  // namespace base