Separate the create and start phases in SchedulerSingleThreadTaskRunnerManager.

base/task_scheduler/scheduler_single_thread_task_runner_manager_unittest.cc

 // Copyright 2017 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/task_scheduler/scheduler_single_thread_task_runner_manager.h"
 
 #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"
 #include "base/task_scheduler/post_task.h"
 #include "base/task_scheduler/scheduler_worker_pool_params.h"
 #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"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <objbase.h>
 
 #include "base/win/current_module.h"
 #endif  // defined(OS_WIN)
@@ skipping 78 matching lines @@
   *thread_priority = PlatformThread::GetCurrentThreadPriority();
 }
 
 void ShouldNotRun() {
   ADD_FAILURE() << "Ran a task that shouldn't run.";
 }
 
 }  // 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(
               TaskTraits().WithShutdownBehavior(
                   TaskShutdownBehavior::BLOCK_SHUTDOWN));
   scoped_refptr<SingleThreadTaskRunner> task_runner_2 =
       single_thread_task_runner_manager_
           ->CreateSingleThreadTaskRunnerWithTraits(
               TaskTraits().WithShutdownBehavior(
                   TaskShutdownBehavior::BLOCK_SHUTDOWN));
 
   PlatformThreadRef thread_ref_1;
   task_runner_1->PostTask(FROM_HERE, Bind(&CaptureThreadRef, &thread_ref_1));
   PlatformThreadRef thread_ref_2;
   task_runner_2->PostTask(FROM_HERE, Bind(&CaptureThreadRef, &thread_ref_2));
 
   task_tracker_.Shutdown();
 
   ASSERT_FALSE(thread_ref_1.is_null());
   ASSERT_FALSE(thread_ref_2.is_null());
   EXPECT_NE(thread_ref_1, thread_ref_2);
 }
 
 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.
   scoped_refptr<SingleThreadTaskRunner> task_runner_background =
       single_thread_task_runner_manager_
           ->CreateSingleThreadTaskRunnerWithTraits(
               TaskTraits().WithPriority(TaskPriority::BACKGROUND));
   scoped_refptr<SingleThreadTaskRunner> task_runner_user_visible =
       single_thread_task_runner_manager_
           ->CreateSingleThreadTaskRunnerWithTraits(
@@ skipping 40 matching lines @@
   waitable_event_user_blocking.Wait();
 
   if (Lock::HandlesMultipleThreadPriorities())
     EXPECT_EQ(ThreadPriority::BACKGROUND, thread_priority_background);
   else
     EXPECT_EQ(ThreadPriority::NORMAL, thread_priority_background);
   EXPECT_EQ(ThreadPriority::NORMAL, thread_priority_user_visible);
   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();
   EXPECT_FALSE(task_runner->PostTask(FROM_HERE, Bind(&ShouldNotRun)));
 }
 
 // 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.
   WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL,
                          WaitableEvent::InitialState::NOT_SIGNALED);
   auto task_runner = single_thread_task_runner_manager_
                          ->CreateSingleThreadTaskRunnerWithTraits(TaskTraits());
   EXPECT_TRUE(task_runner->PostDelayedTask(
       FROM_HERE, Bind(&WaitableEvent::Signal, Unretained(&task_ran)),
       TestTimeouts::tiny_timeout()));
 
   // Wait until the task runs.
   task_ran.Wait();
 
   // Expect the task to run after its delay expires, but not more than 250 ms
   // after that.
   const TimeDelta actual_delay = TimeTicks::Now() - start_time;
   EXPECT_GE(actual_delay, TestTimeouts::tiny_timeout());
   EXPECT_LT(actual_delay,
             TimeDelta::FromMilliseconds(250) + TestTimeouts::tiny_timeout());
 }
 
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest,
        RunsTasksOnCurrentThread) {
+  single_thread_task_runner_manager_->Start();
   scoped_refptr<SingleThreadTaskRunner> task_runner_1 =
       single_thread_task_runner_manager_
           ->CreateSingleThreadTaskRunnerWithTraits(
               TaskTraits().WithShutdownBehavior(
                   TaskShutdownBehavior::BLOCK_SHUTDOWN));
   scoped_refptr<SingleThreadTaskRunner> task_runner_2 =
       single_thread_task_runner_manager_
           ->CreateSingleThreadTaskRunnerWithTraits(
               TaskTraits().WithShutdownBehavior(
                   TaskShutdownBehavior::BLOCK_SHUTDOWN));
@@ skipping 61 matching lines @@
     single_thread_task_runner_manager_.reset();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(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,
                              WaitableEvent::InitialState::NOT_SIGNALED);
   WaitableEvent task_blocking(WaitableEvent::ResetPolicy::MANUAL,
                               WaitableEvent::InitialState::NOT_SIGNALED);
 
   {
     auto task_runner = single_thread_task_runner_manager_
                            ->CreateSingleThreadTaskRunnerWithTraits(
                                TaskTraits().WithBaseSyncPrimitives());
     EXPECT_TRUE(task_runner->PostTask(
         FROM_HERE, Bind(&WaitableEvent::Signal, Unretained(&task_running))));
     EXPECT_TRUE(task_runner->PostTask(
         FROM_HERE, Bind(&WaitableEvent::Wait, Unretained(&task_blocking))));
   }
 
   task_running.Wait();
   CallJoinFromDifferentThread join_from_different_thread(
       single_thread_task_runner_manager_.get());
   join_from_different_thread.Start();
   join_from_different_thread.WaitForRunToStart();
   task_blocking.Signal();
   join_from_different_thread.Join();
 }
 
 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,
                              WaitableEvent::InitialState::NOT_SIGNALED);
   WaitableEvent task_blocking(WaitableEvent::ResetPolicy::MANUAL,
                               WaitableEvent::InitialState::NOT_SIGNALED);
 
   {
     auto task_runner = single_thread_task_runner_manager_
                            ->CreateSingleThreadTaskRunnerWithTraits(
@@ skipping 10 matching lines @@
       single_thread_task_runner_manager_.get());
   join_from_different_thread.Start();
   join_from_different_thread.WaitForRunToStart();
   task_blocking.Signal();
   join_from_different_thread.Join();
 }
 
 #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(
               TaskShutdownBehavior::BLOCK_SHUTDOWN));
 
   com_task_runner->PostTask(
       FROM_HERE, Bind([]() {
         HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
         if (SUCCEEDED(hr)) {
           ADD_FAILURE() << "COM STA was not initialized on this thread";
@@ skipping 43 matching lines @@
   }
 
   bool register_class_succeeded_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(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(
               TaskShutdownBehavior::BLOCK_SHUTDOWN));
   HWND hwnd = nullptr;
   // HWNDs process messages on the thread that created them, so we have to
   // create them within the context of the task runner to properly simulate a
   // COM callback.
   com_task_runner->PostTask(
       FROM_HERE,
@@ skipping 11 matching lines @@
   com_task_runner->PostTask(
       FROM_HERE, Bind([](HWND hwnd) { ::DestroyWindow(hwnd); }, hwnd));
 
   task_tracker_.Shutdown();
 }
 
 #endif  // defined(OS_WIN)
 
 }  // namespace internal
 }  // namespace base