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

base/run_loop_unittest.cc

 // Copyright 2016 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 "base/run_loop.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/macros.h"
 #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 {
 
 namespace {
 
 void QuitWhenIdleTask(RunLoop* run_loop, int* counter) {
   run_loop->QuitWhenIdle();
   ++(*counter);
 }
@@ skipping 31 matching lines @@
   RunLoop run_loop_;
   int counter_ = 0;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RunLoopTest);
 };
 
 }  // namespace
 
 TEST_F(RunLoopTest, QuitWhenIdle) {
-  message_loop_.task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, BindOnce(&QuitWhenIdleTask, Unretained(&run_loop_),
                           Unretained(&counter_)));
-  message_loop_.task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, BindOnce(&ShouldRunTask, Unretained(&counter_)));
-  message_loop_.task_runner()->PostDelayedTask(
+  ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, BindOnce(&ShouldNotRunTask), TimeDelta::FromDays(1));
 
   run_loop_.Run();
   EXPECT_EQ(2, counter_);
 }
 
 TEST_F(RunLoopTest, QuitWhenIdleNestedLoop) {
-  message_loop_.task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, BindOnce(&RunNestedLoopTask, Unretained(&counter_)));
-  message_loop_.task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, BindOnce(&QuitWhenIdleTask, Unretained(&run_loop_),
                           Unretained(&counter_)));
-  message_loop_.task_runner()->PostTask(
+  ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, BindOnce(&ShouldRunTask, Unretained(&counter_)));
-  message_loop_.task_runner()->PostDelayedTask(
+  ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, BindOnce(&ShouldNotRunTask), TimeDelta::FromDays(1));
 
   run_loop_.Run();
   EXPECT_EQ(4, counter_);
 }
 
 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, BindOnce(&ShouldRunTask, Unretained(&counter_)));
-  message_loop_.task_runner()->PostDelayedTask(
+  ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, BindOnce(&ShouldNotRunTask), TimeDelta::FromDays(1));
 
   run_loop_.Run();
   EXPECT_EQ(1, counter_);
 }
 
 // Verify that the QuitWhenIdleClosure() can run after the RunLoop has been
 // deleted. It should have no effect.
 TEST_F(RunLoopTest, QuitWhenIdleClosureAfterRunLoopScope) {
   Closure quit_when_idle_closure;
   {
     RunLoop run_loop;
     quit_when_idle_closure = run_loop.QuitWhenIdleClosure();
     run_loop.RunUntilIdle();
   }
   quit_when_idle_closure.Run();
 }
 
+TEST_F(RunLoopTest, IsRunningOnCurrentThread) {
+  EXPECT_FALSE(RunLoop::IsRunningOnCurrentThread());
+  ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      Bind([]() { EXPECT_TRUE(RunLoop::IsRunningOnCurrentThread()); }));

[danakj, 2017/04/20 14:57:32]

Is there a test for this being false?

[gab, 2017/04/20 16:22:02]

3 lines above on 118 in this test :)

+  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();
+}
+
+class MockNestingObserver : public RunLoop::NestingObserver {
+ public:
+  MockNestingObserver() = default;
+
+  // RunLoop::NestingObserver:
+  MOCK_METHOD0(OnBeginNestedMessageLoop, void());
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockNestingObserver);
+};
+
+TEST_F(RunLoopTest, NestingObservers) {
+  EXPECT_TRUE(RunLoop::IsNestingAllowedOnCurrentThread());
+
+  testing::StrictMock<MockNestingObserver> 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);

[danakj, 2017/04/20 14:57:32]

I don't think you need this, it would change when the errors are printed but
mock doesn't allow calls before the EXPECT happens, it would report unexpected
calls. You can break things and verify if I'm right tho.

[gab, 2017/04/20 16:22:02]

Ah right, removed, thanks

+  EXPECT_CALL(nesting_observer, OnBeginNestedMessageLoop()).Times(2);
+  run_loop_.Run();
+}
+
+// Disabled on Android per http://crbug.com/643760.
+#if defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
+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");
+}
+#endif  // defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
+
 }  // namespace base