WILL BE MERGED Change Ownership of Sequence to the Single Thread SchedulerWorker Delegate

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/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/simple_thread.h"
 #include "base/threading/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace internal {
 
 namespace {
 
-enum WorkerPoolType {
+enum WorkerPoolType : size_t {
   BACKGROUND_WORKER_POOL = 0,
   FOREGROUND_WORKER_POOL,
 };
 
 static size_t GetThreadPoolIndexForTraits(const TaskTraits& traits) {
   return traits.priority() == TaskPriority::BACKGROUND ? BACKGROUND_WORKER_POOL
                                                        : FOREGROUND_WORKER_POOL;
 }
 
+std::vector<SchedulerWorkerPoolParams> GetParamsVector() {
+  using StandbyThreadPolicy = SchedulerWorkerPoolParams::StandbyThreadPolicy;
+
+  std::vector<SchedulerWorkerPoolParams> params_vector;
+
+  DCHECK_EQ(BACKGROUND_WORKER_POOL, params_vector.size());
+  params_vector.emplace_back("Background", ThreadPriority::BACKGROUND,
+                             StandbyThreadPolicy::LAZY, 1U, TimeDelta::Max());
+
+  DCHECK_EQ(FOREGROUND_WORKER_POOL, params_vector.size());
+  params_vector.emplace_back("Foreground", ThreadPriority::NORMAL,
+                             StandbyThreadPolicy::LAZY, 1U, TimeDelta::Max());
+
+  return params_vector;
+}
+
 class TaskSchedulerSingleThreadTaskRunnerManagerTest : public testing::Test {
  public:
   TaskSchedulerSingleThreadTaskRunnerManagerTest()
       : service_thread_("TaskSchedulerServiceThread") {}
 
   void SetUp() override {
     service_thread_.Start();
 
-    using StandbyThreadPolicy = SchedulerWorkerPoolParams::StandbyThreadPolicy;
-
-    std::vector<SchedulerWorkerPoolParams> params_vector;
-
-    ASSERT_EQ(BACKGROUND_WORKER_POOL, params_vector.size());
-    params_vector.emplace_back("Background", ThreadPriority::BACKGROUND,
-                               StandbyThreadPolicy::LAZY, 1U, TimeDelta::Max());
-
-    ASSERT_EQ(FOREGROUND_WORKER_POOL, params_vector.size());
-    params_vector.emplace_back("Foreground", ThreadPriority::NORMAL,
-                               StandbyThreadPolicy::LAZY, 1U, TimeDelta::Max());
-
     delayed_task_manager_ =
         MakeUnique<DelayedTaskManager>(service_thread_.task_runner());
     single_thread_task_runner_manager_ =
         MakeUnique<SchedulerSingleThreadTaskRunnerManager>(
-            params_vector, Bind(&GetThreadPoolIndexForTraits), &task_tracker_,
-            delayed_task_manager_.get());
+            GetParamsVector(), Bind(&GetThreadPoolIndexForTraits),
+            &task_tracker_, delayed_task_manager_.get());
   }
 
   void TearDown() override {
-    single_thread_task_runner_manager_->JoinForTesting();
-    single_thread_task_runner_manager_.reset();
+    TearDownSingleThreadTaskRunnerManager();
     delayed_task_manager_.reset();
     service_thread_.Stop();
   }
 
  protected:
+  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:
   Thread service_thread_;
   std::unique_ptr<DelayedTaskManager> delayed_task_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskSchedulerSingleThreadTaskRunnerManagerTest);
 };
@@ skipping 162 matching lines @@
           [](scoped_refptr<SingleThreadTaskRunner> task_runner_1,
              scoped_refptr<SingleThreadTaskRunner> task_runner_2) {
             EXPECT_FALSE(task_runner_1->RunsTasksOnCurrentThread());
             EXPECT_TRUE(task_runner_2->RunsTasksOnCurrentThread());
           },
           task_runner_1, task_runner_2));
 
   task_tracker_.Shutdown();
 }
 
+namespace {
+
+class CallJoinFromDifferentThread : public SimpleThread {
+ public:
+  CallJoinFromDifferentThread(
+      SchedulerSingleThreadTaskRunnerManager* manager_to_join)
+      : SimpleThread("SchedulerSingleThreadTaskRunnerManagerJoinThread"),
+        manager_to_join_(manager_to_join),
+        run_started_event_(WaitableEvent::ResetPolicy::MANUAL,
+                           WaitableEvent::InitialState::NOT_SIGNALED) {}
+
+  ~CallJoinFromDifferentThread() override = default;
+
+  void Run() override {
+    run_started_event_.Signal();
+    manager_to_join_->JoinForTesting();
+  }
+
+  void WaitForRunToStart() { run_started_event_.Wait(); }
+
+ private:
+  SchedulerSingleThreadTaskRunnerManager* const manager_to_join_;
+  WaitableEvent run_started_event_;
+  DISALLOW_COPY_AND_ASSIGN(CallJoinFromDifferentThread);
+};
+
+class TaskSchedulerSingleThreadTaskRunnerManagerJoinTest
+    : public TaskSchedulerSingleThreadTaskRunnerManagerTest {
+ public:
+  TaskSchedulerSingleThreadTaskRunnerManagerJoinTest() = default;
+  ~TaskSchedulerSingleThreadTaskRunnerManagerJoinTest() override = default;
+
+ protected:
+  void TearDownSingleThreadTaskRunnerManager() override {
+    // The tests themselves are responsible for calling JoinForTesting().
+    single_thread_task_runner_manager_.reset();
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TaskSchedulerSingleThreadTaskRunnerManagerJoinTest);
+};
+
+}  // namespace
+
+TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerJoinTest, ConcurrentJoin) {
+  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) {
+  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))));
+    EXPECT_TRUE(task_runner->PostTask(FROM_HERE, Bind(&DoNothing)));
+  }
+
+  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();
+}
+
 }  // namespace internal
 }  // namespace base