Separate the create and start phases in SchedulerSingleThreadTaskRunnerManager.

base/task_scheduler/scheduler_single_thread_task_runner_manager_unittest.cc

Index: base/task_scheduler/scheduler_single_thread_task_runner_manager_unittest.cc
diff --git a/base/task_scheduler/scheduler_single_thread_task_runner_manager_unittest.cc b/base/task_scheduler/scheduler_single_thread_task_runner_manager_unittest.cc
index 0c3c0b60efdc5a4f21f1c7bb713504bada1660e8..571c5335020f9147605365b1a1b3b23fda218b82 100644
--- a/base/task_scheduler/scheduler_single_thread_task_runner_manager_unittest.cc
+++ b/base/task_scheduler/scheduler_single_thread_task_runner_manager_unittest.cc
@@ -6,6 +6,7 @@
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
+#include "base/synchronization/atomic_flag.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task_scheduler/delayed_task_manager.h"
@@ -14,6 +15,7 @@
 #include "base/task_scheduler/task_tracker.h"
 #include "base/task_scheduler/task_traits.h"
 #include "base/test/test_timeouts.h"
+#include "base/threading/platform_thread.h"
 #include "base/threading/simple_thread.h"
 #include "base/threading/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -112,6 +114,7 @@ void ShouldNotRun() {
 }  // namespace
 
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, DifferentThreadsUsed) {
+  single_thread_task_runner_manager_->Start();

[robliao, 2017/04/10 20:52:48]

Given the majority of the tests start the task runner manager as the first
thing, this may make more sense in the helper class and then PostTaskBeforeStart
should be special cased.

[fdoray, 2017/04/11 15:27:24]

Done.

   scoped_refptr<SingleThreadTaskRunner> task_runner_1 =
       single_thread_task_runner_manager_
           ->CreateSingleThreadTaskRunnerWithTraits(
@@ -136,6 +139,7 @@ TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, DifferentThreadsUsed) {
 }
 
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PrioritySetCorrectly) {
+  single_thread_task_runner_manager_->Start();
   // Why are events used here instead of the task tracker?
   // Shutting down can cause priorities to get raised. This means we have to use
   // events to determine when a task is run.
@@ -196,7 +200,38 @@ TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PrioritySetCorrectly) {
   EXPECT_EQ(ThreadPriority::NORMAL, thread_priority_user_blocking);
 }
 
+// Verify that a task posted before Start() doesn't run until Start() is called.
+TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PostTaskBeforeStart) {
+  AtomicFlag manager_started;
+  WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL,
+                             WaitableEvent::InitialState::NOT_SIGNALED);
+  single_thread_task_runner_manager_
+      ->CreateSingleThreadTaskRunnerWithTraits(TaskTraits())
+      ->PostTask(
+          FROM_HERE,
+          Bind(
+              [](WaitableEvent* task_running, AtomicFlag* manager_started) {
+                task_running->Signal();
+
+                // The task should not run before Start().
+                EXPECT_TRUE(manager_started->IsSet());
+              },
+              Unretained(&task_running), Unretained(&manager_started)));
+
+  // Wait a little bit to make sure that the task isn't scheduled before start.
+  // Note: This test won't catch a case where the task is scheduled between
+  // setting |manager_started| and calling Start(). However, we expect the test
+  // to be flaky if the tested code allows that to happen.
+  PlatformThread::Sleep(TestTimeouts::tiny_timeout());
+  manager_started.Set();
+  single_thread_task_runner_manager_->Start();
+
+  // This should not hang if the task is scheduled after Start().
+  task_running.Wait();
+}
+
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PostTaskAfterShutdown) {
+  single_thread_task_runner_manager_->Start();
   auto task_runner = single_thread_task_runner_manager_
                          ->CreateSingleThreadTaskRunnerWithTraits(TaskTraits());
   task_tracker_.Shutdown();
@@ -205,6 +240,7 @@ TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PostTaskAfterShutdown) {
 
 // Verify that a Task runs shortly after its delay expires.
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PostDelayedTask) {
+  single_thread_task_runner_manager_->Start();
   TimeTicks start_time = TimeTicks::Now();
 
   // Post a task with a short delay.
@@ -229,6 +265,7 @@ TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PostDelayedTask) {
 
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest,
        RunsTasksOnCurrentThread) {
+  single_thread_task_runner_manager_->Start();
   scoped_refptr<SingleThreadTaskRunner> task_runner_1 =
       single_thread_task_runner_manager_
           ->CreateSingleThreadTaskRunnerWithTraits(
@@ -310,6 +347,7 @@ class TaskSchedulerSingleThreadTaskRunnerManagerJoinTest
 }  // namespace
 
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerJoinTest, ConcurrentJoin) {
+  single_thread_task_runner_manager_->Start();
   // Exercises the codepath where the workers are unavailable for unregistration
   // because of a Join call.
   WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL,
@@ -338,6 +376,7 @@ TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerJoinTest, ConcurrentJoin) {
 
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerJoinTest,
        ConcurrentJoinExtraSkippedTask) {
+  single_thread_task_runner_manager_->Start();
   // Tests to make sure that tasks are properly cleaned up at Join, allowing
   // SingleThreadTaskRunners to unregister themselves.
   WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL,
@@ -368,6 +407,7 @@ TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerJoinTest,
 #if defined(OS_WIN)
 
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, COMSTAInitialized) {
+  single_thread_task_runner_manager_->Start();
   scoped_refptr<SingleThreadTaskRunner> com_task_runner =
       single_thread_task_runner_manager_->CreateCOMSTATaskRunnerWithTraits(
           TaskTraits().WithShutdownBehavior(
@@ -431,6 +471,7 @@ class TaskSchedulerSingleThreadTaskRunnerManagerTestWin
 }  // namespace
 
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTestWin, PumpsMessages) {
+  single_thread_task_runner_manager_->Start();
   scoped_refptr<SingleThreadTaskRunner> com_task_runner =
       single_thread_task_runner_manager_->CreateCOMSTATaskRunnerWithTraits(
           TaskTraits().WithShutdownBehavior(