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 36 matching lines @@
 
   void SetUp() override {
     service_thread_.Start();
 
     delayed_task_manager_ =
         MakeUnique<DelayedTaskManager>(service_thread_.task_runner());
     single_thread_task_runner_manager_ =
         MakeUnique<SchedulerSingleThreadTaskRunnerManager>(
             GetParamsVector(), Bind(&GetThreadPoolIndexForTraits),
             &task_tracker_, delayed_task_manager_.get());
+    StartSingleThreadTaskRunnerManagerFromSetup();
   }
 
   void TearDown() override {
     TearDownSingleThreadTaskRunnerManager();
     delayed_task_manager_.reset();
     service_thread_.Stop();
   }
 
  protected:
+  virtual void StartSingleThreadTaskRunnerManagerFromSetup() {
+    single_thread_task_runner_manager_->Start();
+  }
+
   virtual void TearDownSingleThreadTaskRunnerManager() {
     single_thread_task_runner_manager_->JoinForTesting();
     single_thread_task_runner_manager_.reset();
   }
 
   std::unique_ptr<SchedulerSingleThreadTaskRunnerManager>
       single_thread_task_runner_manager_;
   TaskTracker task_tracker_;
 
  private:
@@ skipping 361 matching lines @@
   SendMessage(hwnd, WM_USER, 0, 0);
 
   com_task_runner->PostTask(
       FROM_HERE, Bind([](HWND hwnd) { ::DestroyWindow(hwnd); }, hwnd));
 
   task_tracker_.Shutdown();
 }
 
 #endif  // defined(OS_WIN)
 
+namespace {
+
+class TaskSchedulerSingleThreadTaskRunnerManagerStartTest
+    : public TaskSchedulerSingleThreadTaskRunnerManagerTest {
+ public:
+  TaskSchedulerSingleThreadTaskRunnerManagerStartTest() = default;
+
+ private:
+  void StartSingleThreadTaskRunnerManagerFromSetup() override {
+    // Start() will be called in the test body.
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(TaskSchedulerSingleThreadTaskRunnerManagerStartTest);
+};
+
+}  // namespace
+
+// Verify that a task posted before Start() doesn't run until Start() is called.
+// Don't use the TaskSchedulerSingleThreadTaskRunnerManagerTest fixture
+TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerStartTest,
+       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();
+}
+
 }  // namespace internal
 }  // namespace base