TaskScheduler: Remove base/task_scheduler/utils.h/.cc

base/task_scheduler/scheduler_thread_pool_impl_unittest.cc

 // Copyright 2016 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_thread_pool.h"
+#include "base/task_scheduler/scheduler_thread_pool_impl.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <unordered_set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
@@ skipping 12 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace internal {
 namespace {
 
 const size_t kNumThreadsInThreadPool = 4;
 const size_t kNumThreadsPostingTasks = 4;
 const size_t kNumTasksPostedPerThread = 150;
 
-class TaskSchedulerThreadPoolTest
+class TestDelayedTaskManager : public DelayedTaskManager {
+ public:
+  TestDelayedTaskManager() : DelayedTaskManager(Bind(&DoNothing)) {}
+
+  void SetCurrentTime(TimeTicks now) { now_ = now; }
+
+  // DelayedTaskManager:
+  TimeTicks Now() const override { return now_; }
+
+ private:
+  TimeTicks now_ = TimeTicks::Now();
+
+  DISALLOW_COPY_AND_ASSIGN(TestDelayedTaskManager);
+};
+
+class TaskSchedulerThreadPoolImplTest
     : public testing::TestWithParam<ExecutionMode> {
  protected:
-  TaskSchedulerThreadPoolTest() : delayed_task_manager_(Bind(&DoNothing)) {}
+  TaskSchedulerThreadPoolImplTest() = default;
 
   void SetUp() override {
-    thread_pool_ = SchedulerThreadPool::CreateThreadPool(
+    thread_pool_ = SchedulerThreadPoolImpl::CreateThreadPool(
         ThreadPriority::NORMAL, kNumThreadsInThreadPool,
-        Bind(&TaskSchedulerThreadPoolTest::EnqueueSequenceCallback,
+        Bind(&TaskSchedulerThreadPoolImplTest::ReEnqueueSequenceCallback,
              Unretained(this)),
         &task_tracker_, &delayed_task_manager_);
     ASSERT_TRUE(thread_pool_);
   }
 
   void TearDown() override {
     thread_pool_->WaitForAllWorkerThreadsIdleForTesting();
     thread_pool_->JoinForTesting();
   }
 
-  std::unique_ptr<SchedulerThreadPool> thread_pool_;
+  std::unique_ptr<SchedulerThreadPoolImpl> thread_pool_;
+
+  TaskTracker task_tracker_;
+  TestDelayedTaskManager delayed_task_manager_;
 
  private:
-  void EnqueueSequenceCallback(scoped_refptr<Sequence> sequence) {
+  void ReEnqueueSequenceCallback(scoped_refptr<Sequence> sequence) {
     // In production code, this callback would be implemented by the
     // TaskScheduler which would first determine which PriorityQueue the
-    // sequence must be reinserted.
+    // sequence must be re-enqueued.
     const SequenceSortKey sort_key(sequence->GetSortKey());
-    thread_pool_->EnqueueSequence(std::move(sequence), sort_key);
+    thread_pool_->ReEnqueueSequence(std::move(sequence), sort_key);
   }
 
-  TaskTracker task_tracker_;
-  DelayedTaskManager delayed_task_manager_;
-
-  DISALLOW_COPY_AND_ASSIGN(TaskSchedulerThreadPoolTest);
+  DISALLOW_COPY_AND_ASSIGN(TaskSchedulerThreadPoolImplTest);
 };
 
 class TaskFactory {
  public:
   // Constructs a TaskFactory that posts tasks with |execution_mode| to
   // |thread_pool|.
-  TaskFactory(SchedulerThreadPool* thread_pool, ExecutionMode execution_mode)
+  TaskFactory(SchedulerThreadPoolImpl* thread_pool,
+              ExecutionMode execution_mode)
       : cv_(&lock_),
         task_runner_(thread_pool->CreateTaskRunnerWithTraits(TaskTraits(),
                                                              execution_mode)),
         execution_mode_(execution_mode) {}
 
   // Posts a task through |task_runner_|. If |post_nested_task| is true, the
   // task will post a new task when it runs. If |event| is set, the task will
   // block until it is signaled.
   void PostTestTask(bool post_nested_task, WaitableEvent* event) {
     AutoLock auto_lock(lock_);
@@ skipping 67 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TaskFactory);
 };
 
 class ThreadPostingTasks : public SimpleThread {
  public:
   // Constructs a thread that posts tasks to |thread_pool| through an
   // |execution_mode| task runner. If |wait_for_all_threads_idle| is true, the
   // thread wait until all worker threads in |thread_pool| are idle before
   // posting a new task. If |post_nested_task| is true, each task posted by this
   // thread posts another task when it runs.
-  ThreadPostingTasks(SchedulerThreadPool* thread_pool,
+  ThreadPostingTasks(SchedulerThreadPoolImpl* thread_pool,
                      ExecutionMode execution_mode,
                      bool wait_for_all_threads_idle,
                      bool post_nested_task)
       : SimpleThread("ThreadPostingTasks"),
         thread_pool_(thread_pool),
         wait_for_all_threads_idle_(wait_for_all_threads_idle),
         post_nested_task_(post_nested_task),
         factory_(thread_pool_, execution_mode) {
     DCHECK(thread_pool_);
   }
 
   const TaskFactory* factory() const { return &factory_; }
 
  private:
   void Run() override {
     EXPECT_FALSE(factory_.task_runner()->RunsTasksOnCurrentThread());
 
     for (size_t i = 0; i < kNumTasksPostedPerThread; ++i) {
       if (wait_for_all_threads_idle_)
         thread_pool_->WaitForAllWorkerThreadsIdleForTesting();
       factory_.PostTestTask(post_nested_task_, nullptr);
     }
   }
 
-  SchedulerThreadPool* const thread_pool_;
+  SchedulerThreadPoolImpl* const thread_pool_;
   const scoped_refptr<TaskRunner> task_runner_;
   const bool wait_for_all_threads_idle_;
   const bool post_nested_task_;
   TaskFactory factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadPostingTasks);
 };
 
-TEST_P(TaskSchedulerThreadPoolTest, PostTasks) {
+void ShouldNotRunCallback() {
+  ADD_FAILURE() << "Ran a task that shouldn't run.";
+}
+
+void SignalEventCallback(WaitableEvent* event) {
+  DCHECK(event);
+  event->Signal();
+}
+
+}  // namespace
+
+TEST_P(TaskSchedulerThreadPoolImplTest, PostTasks) {
   // Create threads to post tasks.
   std::vector<std::unique_ptr<ThreadPostingTasks>> threads_posting_tasks;
   for (size_t i = 0; i < kNumThreadsPostingTasks; ++i) {
     const bool kWaitForAllThreadIdle = false;
     const bool kPostNestedTasks = false;
     threads_posting_tasks.push_back(WrapUnique(
         new ThreadPostingTasks(thread_pool_.get(), GetParam(),
                                kWaitForAllThreadIdle, kPostNestedTasks)));
     threads_posting_tasks.back()->Start();
   }
 
   // Wait for all tasks to run.
   for (const auto& thread_posting_tasks : threads_posting_tasks) {
     thread_posting_tasks->Join();
     thread_posting_tasks->factory()->WaitForAllTasksToRun();
     EXPECT_EQ(kNumTasksPostedPerThread,
               thread_posting_tasks->factory()->NumRunTasks());
   }
 
   // Wait until all worker threads are idle to be sure that no task accesses
   // its TaskFactory after |thread_posting_tasks| is destroyed.
   thread_pool_->WaitForAllWorkerThreadsIdleForTesting();
 }
 
-TEST_P(TaskSchedulerThreadPoolTest, PostTasksWaitAllThreadsIdle) {
+TEST_P(TaskSchedulerThreadPoolImplTest, PostTasksWaitAllThreadsIdle) {
   // Create threads to post tasks. To verify that worker threads can sleep and
   // be woken up when new tasks are posted, wait for all threads to become idle
   // before posting a new task.
   std::vector<std::unique_ptr<ThreadPostingTasks>> threads_posting_tasks;
   for (size_t i = 0; i < kNumThreadsPostingTasks; ++i) {
     const bool kWaitForAllThreadIdle = true;
     const bool kPostNestedTasks = false;
     threads_posting_tasks.push_back(WrapUnique(
         new ThreadPostingTasks(thread_pool_.get(), GetParam(),
                                kWaitForAllThreadIdle, kPostNestedTasks)));
     threads_posting_tasks.back()->Start();
   }
 
   // Wait for all tasks to run.
   for (const auto& thread_posting_tasks : threads_posting_tasks) {
     thread_posting_tasks->Join();
     thread_posting_tasks->factory()->WaitForAllTasksToRun();
     EXPECT_EQ(kNumTasksPostedPerThread,
               thread_posting_tasks->factory()->NumRunTasks());
   }
 
   // Wait until all worker threads are idle to be sure that no task accesses
   // its TaskFactory after |thread_posting_tasks| is destroyed.
   thread_pool_->WaitForAllWorkerThreadsIdleForTesting();
 }
 
-TEST_P(TaskSchedulerThreadPoolTest, NestedPostTasks) {
+TEST_P(TaskSchedulerThreadPoolImplTest, NestedPostTasks) {
   // Create threads to post tasks. Each task posted by these threads will post
   // another task when it runs.
   std::vector<std::unique_ptr<ThreadPostingTasks>> threads_posting_tasks;
   for (size_t i = 0; i < kNumThreadsPostingTasks; ++i) {
     const bool kWaitForAllThreadIdle = false;
     const bool kPostNestedTasks = true;
     threads_posting_tasks.push_back(WrapUnique(
         new ThreadPostingTasks(thread_pool_.get(), GetParam(),
                                kWaitForAllThreadIdle, kPostNestedTasks)));
     threads_posting_tasks.back()->Start();
   }
 
   // Wait for all tasks to run.
   for (const auto& thread_posting_tasks : threads_posting_tasks) {
     thread_posting_tasks->Join();
     thread_posting_tasks->factory()->WaitForAllTasksToRun();
     EXPECT_EQ(2 * kNumTasksPostedPerThread,
               thread_posting_tasks->factory()->NumRunTasks());
   }
 
   // Wait until all worker threads are idle to be sure that no task accesses
   // its TaskFactory after |thread_posting_tasks| is destroyed.
   thread_pool_->WaitForAllWorkerThreadsIdleForTesting();
 }
 
-TEST_P(TaskSchedulerThreadPoolTest, PostTasksWithOneAvailableThread) {
+TEST_P(TaskSchedulerThreadPoolImplTest, PostTasksWithOneAvailableThread) {
   // Post tasks to keep all threads busy except one until |event| is signaled.
   // Use different factories so that tasks are added to different sequences and
   // can run simultaneously when the execution mode is SEQUENCED.
   WaitableEvent event(true, false);
   std::vector<std::unique_ptr<TaskFactory>> blocked_task_factories;
   for (size_t i = 0; i < (kNumThreadsInThreadPool - 1); ++i) {
     blocked_task_factories.push_back(
         WrapUnique(new TaskFactory(thread_pool_.get(), GetParam())));
     blocked_task_factories.back()->PostTestTask(false, &event);
     blocked_task_factories.back()->WaitForAllTasksToRun();
   }
 
   // Post |kNumTasksPostedPerThread| tasks that should all run despite the fact
   // that only one thread in |thread_pool_| isn't busy.
   TaskFactory short_task_factory(thread_pool_.get(), GetParam());
   for (size_t i = 0; i < kNumTasksPostedPerThread; ++i)
     short_task_factory.PostTestTask(false, nullptr);
   short_task_factory.WaitForAllTasksToRun();
 
   // Release tasks waiting on |event|.
   event.Signal();
 
   // Wait until all worker threads are idle to be sure that no task accesses
   // its TaskFactory after it is destroyed.
   thread_pool_->WaitForAllWorkerThreadsIdleForTesting();
 }
 
-TEST_P(TaskSchedulerThreadPoolTest, Saturate) {
+TEST_P(TaskSchedulerThreadPoolImplTest, Saturate) {
   // Verify that it is possible to have |kNumThreadsInThreadPool|
   // tasks/sequences running simultaneously. Use different factories so that
   // tasks are added to different sequences and can run simultaneously when the
   // execution mode is SEQUENCED.
   WaitableEvent event(true, false);
   std::vector<std::unique_ptr<TaskFactory>> factories;
   for (size_t i = 0; i < kNumThreadsInThreadPool; ++i) {
     factories.push_back(
         WrapUnique(new TaskFactory(thread_pool_.get(), GetParam())));
     factories.back()->PostTestTask(false, &event);
     factories.back()->WaitForAllTasksToRun();
   }
 
   // Release tasks waiting on |event|.
   event.Signal();
 
   // Wait until all worker threads are idle to be sure that no task accesses
   // its TaskFactory after it is destroyed.
   thread_pool_->WaitForAllWorkerThreadsIdleForTesting();
 }
 
+// Verify that a Task can't be posted after shutdown.
+TEST_P(TaskSchedulerThreadPoolImplTest, PostTaskAfterShutdown) {
+  auto task_runner =
+      thread_pool_->CreateTaskRunnerWithTraits(TaskTraits(), GetParam());
+  task_tracker_.Shutdown();
+  EXPECT_FALSE(task_runner->PostTask(FROM_HERE, Bind(&ShouldNotRunCallback)));
+}
+
+// Verify that a Task posted with a delay is added to the DelayedTaskManager and
+// doesn't run before its delay expires.
+TEST_P(TaskSchedulerThreadPoolImplTest, PostDelayedTask) {
+  EXPECT_TRUE(delayed_task_manager_.GetDelayedRunTime().is_null());
+
+  // Post a delayed task.
+  WaitableEvent task_ran(true, false);
+  EXPECT_TRUE(thread_pool_->CreateTaskRunnerWithTraits(TaskTraits(), GetParam())
+                  ->PostDelayedTask(FROM_HERE, Bind(&SignalEventCallback,
+                                                    Unretained(&task_ran)),
+                                    TimeDelta::FromSeconds(10)));
+
+  // The task should have been added to the DelayedTaskManager.
+  EXPECT_FALSE(delayed_task_manager_.GetDelayedRunTime().is_null());
+
+  // The task shouldn't run.
+  EXPECT_FALSE(task_ran.IsSignaled());
+
+  // Fast-forward time and post tasks that are ripe for execution.
+  delayed_task_manager_.SetCurrentTime(
+      delayed_task_manager_.GetDelayedRunTime());
+  delayed_task_manager_.PostReadyTasks();
+
+  // The task should run.
+  task_ran.Wait();
+}
+
 INSTANTIATE_TEST_CASE_P(Parallel,
-                        TaskSchedulerThreadPoolTest,
+                        TaskSchedulerThreadPoolImplTest,
                         ::testing::Values(ExecutionMode::PARALLEL));
 INSTANTIATE_TEST_CASE_P(Sequenced,
-                        TaskSchedulerThreadPoolTest,
+                        TaskSchedulerThreadPoolImplTest,
                         ::testing::Values(ExecutionMode::SEQUENCED));
 
-}  // namespace
 }  // namespace internal
 }  // namespace base