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..234d9406f9697816271b06f35287a84c8cb19e28 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
@@ -14,6 +14,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 +113,7 @@ void ShouldNotRun() {
 }  // namespace
 
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, DifferentThreadsUsed) {
+  single_thread_task_runner_manager_->Start();
   scoped_refptr<SingleThreadTaskRunner> task_runner_1 =
       single_thread_task_runner_manager_
           ->CreateSingleThreadTaskRunnerWithTraits(
@@ -136,6 +138,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 +199,37 @@ 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) {
+  bool started = false;
+  WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL,
+                             WaitableEvent::InitialState::NOT_SIGNALED);
+  single_thread_task_runner_manager_
+      ->CreateSingleThreadTaskRunnerWithTraits(TaskTraits())
+      ->PostTask(FROM_HERE,
+                 Bind(
+                     [](WaitableEvent* task_running, bool* started) {
+                       task_running->Signal();
+
+                       // The task should not run before Start().
+                       EXPECT_TRUE(*started);
+                     },
+                     Unretained(&task_running), Unretained(&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 |start| and calling Start(). However, we expect the test to be
+  // flaky if the tested code allows that to happen.
+  PlatformThread::Sleep(TestTimeouts::tiny_timeout());
+  started = true;

[gab, 2017/04/10 18:04:56]

Need to use AtomicFlag or this a data race (no such thing as a "benign data
race":
https://software.intel.com/en-us/blogs/2013/01/06/benign-data-races-what-coul...)

[fdoray, 2017/04/10 19:05:00]

Done.

+  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 +238,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 +263,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 +345,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 +374,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 +405,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 +469,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(