TaskScheduler: Add TaskTraits::WithWait().

base/task_scheduler/scheduler_worker_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_worker_pool_impl.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <unordered_set>
@@ skipping 96 matching lines @@
     const SequenceSortKey sort_key(sequence->GetSortKey());
     worker_pool_->ReEnqueueSequence(std::move(sequence), sort_key);
   }
 
   DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerPoolImplTest);
 };
 
 scoped_refptr<TaskRunner> CreateTaskRunnerWithExecutionMode(
     SchedulerWorkerPoolImpl* worker_pool,
     test::ExecutionMode execution_mode) {
+  // Allow tasks posted to the returned TaskRunner to wait on a WaitableEvent.
+  const TaskTraits traits = TaskTraits().WithWait();
   switch (execution_mode) {
     case test::ExecutionMode::PARALLEL:
-      return worker_pool->CreateTaskRunnerWithTraits(TaskTraits());
+      return worker_pool->CreateTaskRunnerWithTraits(traits);
     case test::ExecutionMode::SEQUENCED:
-      return worker_pool->CreateSequencedTaskRunnerWithTraits(TaskTraits());
+      return worker_pool->CreateSequencedTaskRunnerWithTraits(traits);
     case test::ExecutionMode::SINGLE_THREADED:
-      return worker_pool->CreateSingleThreadTaskRunnerWithTraits(TaskTraits());
+      return worker_pool->CreateSingleThreadTaskRunnerWithTraits(traits);
   }
   ADD_FAILURE() << "Unknown ExecutionMode";
   return nullptr;
 }
 
 using PostNestedTask = test::TestTaskFactory::PostNestedTask;
 
 class ThreadPostingTasks : public SimpleThread {
  public:
   enum class WaitBeforePostTask {
@@ skipping 400 matching lines @@
 };
 
 }  // namespace
 
 // Checks that at least one thread has detached by checking the TLS.
 TEST_F(TaskSchedulerWorkerPoolCheckTlsReuse, CheckDetachedThreads) {
   // Saturate the threads and mark each thread with a magic TLS value.
   std::vector<std::unique_ptr<test::TestTaskFactory>> factories;
   for (size_t i = 0; i < kNumWorkersInWorkerPool; ++i) {
     factories.push_back(MakeUnique<test::TestTaskFactory>(
-        worker_pool_->CreateTaskRunnerWithTraits(TaskTraits()),
+        worker_pool_->CreateTaskRunnerWithTraits(TaskTraits().WithWait()),
         test::ExecutionMode::PARALLEL));
     ASSERT_TRUE(factories.back()->PostTask(
         PostNestedTask::NO,
         Bind(&TaskSchedulerWorkerPoolCheckTlsReuse::SetTlsValueAndWait,
              Unretained(this))));
     factories.back()->WaitForAllTasksToRun();
   }
 
   // Release tasks waiting on |waiter_|.
   waiter_.Signal();
@@ skipping 50 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerPoolHistogramTest);
 };
 
 }  // namespace
 
 TEST_F(TaskSchedulerWorkerPoolHistogramTest, NumTasksBetweenWaits) {
   WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
                       WaitableEvent::InitialState::NOT_SIGNALED);
   InitializeWorkerPool(TimeDelta::Max(), kNumWorkersInWorkerPool);
-  auto task_runner =
-      worker_pool_->CreateSequencedTaskRunnerWithTraits(TaskTraits());
+  auto task_runner = worker_pool_->CreateSequencedTaskRunnerWithTraits(
+      TaskTraits().WithWait());
 
   // Post a task.
   task_runner->PostTask(FROM_HERE,
                         Bind(&WaitableEvent::Wait, Unretained(&event)));
 
   // Post 2 more tasks while the first task hasn't completed its execution. It
   // is guaranteed that these tasks will run immediately after the first task,
   // without allowing the worker to sleep.
   task_runner->PostTask(FROM_HERE, Bind(&DoNothing));
   task_runner->PostTask(FROM_HERE, Bind(&DoNothing));
@@ skipping 22 matching lines @@
   signal_event->Signal();
   wait_event->Wait();
 }
 
 }  // namespace
 
 TEST_F(TaskSchedulerWorkerPoolHistogramTest, NumTasksBetweenWaitsWithDetach) {
   WaitableEvent tasks_can_exit_event(WaitableEvent::ResetPolicy::MANUAL,
                                      WaitableEvent::InitialState::NOT_SIGNALED);
   InitializeWorkerPool(kReclaimTimeForDetachTests, kNumWorkersInWorkerPool);
-  auto task_runner = worker_pool_->CreateTaskRunnerWithTraits(TaskTraits());
+  auto task_runner =
+      worker_pool_->CreateTaskRunnerWithTraits(TaskTraits().WithWait());
 
   // Post tasks to saturate the pool.
   std::vector<std::unique_ptr<WaitableEvent>> task_started_events;
   for (size_t i = 0; i < kNumWorkersInWorkerPool; ++i) {
     task_started_events.push_back(
         MakeUnique<WaitableEvent>(WaitableEvent::ResetPolicy::MANUAL,
                                   WaitableEvent::InitialState::NOT_SIGNALED));
     task_runner->PostTask(
         FROM_HERE,
         Bind(&SignalAndWaitEvent, Unretained(task_started_events.back().get()),
@@ skipping 123 matching lines @@
                                 StandbyThreadPolicy::ONE, 8U, TimeDelta::Max()),
       Bind(&NotReachedReEnqueueSequenceCallback), &task_tracker,
       &delayed_task_manager);
   ASSERT_TRUE(worker_pool);
   EXPECT_EQ(1U, worker_pool->NumberOfAliveWorkersForTesting());
   worker_pool->JoinForTesting();
 }
 
 }  // namespace internal
 }  // namespace base