Do not inherit TaskPriority in TaskTraits.

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 106 matching lines @@
 
   DelayedTaskManager delayed_task_manager_;
 
   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().WithBaseSyncPrimitives();
+  const TaskTraits traits = test::CreateTaskTraits().WithBaseSyncPrimitives();
   switch (execution_mode) {
     case test::ExecutionMode::PARALLEL:
       return worker_pool->CreateTaskRunnerWithTraits(traits);
     case test::ExecutionMode::SEQUENCED:
       return worker_pool->CreateSequencedTaskRunnerWithTraits(traits);
     default:
       // Fall through.
       break;
   }
   ADD_FAILURE() << "Unexpected ExecutionMode";
@@ skipping 217 matching lines @@
 
 // Verify that the RunsTasksOnCurrentThread() method of a SEQUENCED TaskRunner
 // returns false when called from a task that isn't part of the sequence. Note:
 // Tests that use TestTaskFactory already verify that RunsTasksOnCurrentThread()
 // returns true when appropriate so this method complements it to get full
 // coverage of that method.
 TEST_P(TaskSchedulerWorkerPoolImplTest, SequencedRunsTasksOnCurrentThread) {
   auto task_runner =
       CreateTaskRunnerWithExecutionMode(worker_pool_.get(), GetParam());
   auto sequenced_task_runner =
-      worker_pool_->CreateSequencedTaskRunnerWithTraits(TaskTraits());
+      worker_pool_->CreateSequencedTaskRunnerWithTraits(
+          test::CreateTaskTraits());
 
   WaitableEvent task_ran(WaitableEvent::ResetPolicy::MANUAL,
                          WaitableEvent::InitialState::NOT_SIGNALED);
   task_runner->PostTask(
       FROM_HERE,
       BindOnce(
           [](scoped_refptr<TaskRunner> sequenced_task_runner,
              WaitableEvent* task_ran) {
             EXPECT_FALSE(sequenced_task_runner->RunsTasksOnCurrentThread());
             task_ran->Signal();
@@ skipping 42 matching lines @@
   WaitableEvent task_2_scheduled(WaitableEvent::ResetPolicy::MANUAL,
                                  WaitableEvent::InitialState::NOT_SIGNALED);
 
   // This event is used to prevent a task from completing before the other task
   // is scheduled. If that happened, both tasks could run on the same worker and
   // this test couldn't verify that the correct number of workers were woken up.
   WaitableEvent barrier(WaitableEvent::ResetPolicy::MANUAL,
                         WaitableEvent::InitialState::NOT_SIGNALED);
 
   worker_pool_
-      ->CreateTaskRunnerWithTraits(TaskTraits().WithBaseSyncPrimitives())
+      ->CreateTaskRunnerWithTraits(
+          test::CreateTaskTraits().WithBaseSyncPrimitives())
       ->PostTask(FROM_HERE,
                  Bind(&TaskPostedBeforeStart, Unretained(&task_1_thread_ref),
                       Unretained(&task_1_scheduled), Unretained(&barrier)));
   worker_pool_
-      ->CreateTaskRunnerWithTraits(TaskTraits().WithBaseSyncPrimitives())
+      ->CreateTaskRunnerWithTraits(
+          test::CreateTaskTraits().WithBaseSyncPrimitives())
       ->PostTask(FROM_HERE,
                  Bind(&TaskPostedBeforeStart, Unretained(&task_2_thread_ref),
                       Unretained(&task_2_scheduled), Unretained(&barrier)));
 
   // Workers should not be created and tasks should not run before the pool is
   // started.
   EXPECT_EQ(0U, worker_pool_->NumberOfAliveWorkersForTesting());
   EXPECT_FALSE(task_1_scheduled.IsSignaled());
   EXPECT_FALSE(task_2_scheduled.IsSignaled());
 
@@ skipping 52 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().WithBaseSyncPrimitives()),
+            test::CreateTaskTraits().WithBaseSyncPrimitives()),
         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 51 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TaskSchedulerWorkerPoolHistogramTest);
 };
 
 }  // namespace
 
 TEST_F(TaskSchedulerWorkerPoolHistogramTest, NumTasksBetweenWaits) {
   WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
                       WaitableEvent::InitialState::NOT_SIGNALED);
   CreateAndStartWorkerPool(TimeDelta::Max(), kNumWorkersInWorkerPool);
   auto task_runner = worker_pool_->CreateSequencedTaskRunnerWithTraits(
-      TaskTraits().WithBaseSyncPrimitives());
+      test::CreateTaskTraits().WithBaseSyncPrimitives());
 
   // Post a task.
   task_runner->PostTask(FROM_HERE,
                         BindOnce(&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, BindOnce(&DoNothing));
   task_runner->PostTask(FROM_HERE, BindOnce(&DoNothing));
@@ skipping 23 matching lines @@
   wait_event->Wait();
 }
 
 }  // namespace
 
 TEST_F(TaskSchedulerWorkerPoolHistogramTest, NumTasksBetweenWaitsWithDetach) {
   WaitableEvent tasks_can_exit_event(WaitableEvent::ResetPolicy::MANUAL,
                                      WaitableEvent::InitialState::NOT_SIGNALED);
   CreateAndStartWorkerPool(kReclaimTimeForDetachTests, kNumWorkersInWorkerPool);
   auto task_runner = worker_pool_->CreateTaskRunnerWithTraits(
-      TaskTraits().WithBaseSyncPrimitives());
+      test::CreateTaskTraits().WithBaseSyncPrimitives());
 
   // 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,
                           BindOnce(&SignalAndWaitEvent,
                                    Unretained(task_started_events.back().get()),
@@ skipping 43 matching lines @@
   tasks_can_exit_event.Signal();
   worker_pool_->WaitForAllWorkersIdleForTesting();
   worker_pool_->DisallowWorkerDetachmentForTesting();
 }
 
 TEST_F(TaskSchedulerWorkerPoolHistogramTest, NumTasksBeforeDetach) {
   CreateAndStartWorkerPool(kReclaimTimeForDetachTests, kNumWorkersInWorkerPool);
 
   auto histogrammed_thread_task_runner =
       worker_pool_->CreateSequencedTaskRunnerWithTraits(
-          TaskTraits().WithBaseSyncPrimitives());
+          test::CreateTaskTraits().WithBaseSyncPrimitives());
 
   // Post 3 tasks and hold the thread for idle thread stack ordering.
   // This test assumes |histogrammed_thread_task_runner| gets assigned the same
   // thread for each of its tasks.
   PlatformThreadRef thread_ref;
   histogrammed_thread_task_runner->PostTask(
       FROM_HERE, BindOnce(
                      [](PlatformThreadRef* thread_ref) {
                        ASSERT_TRUE(thread_ref);
                        *thread_ref = PlatformThread::CurrentRef();
@@ skipping 37 matching lines @@
   // release and go idle. This allows the SchedulerWorker associated with
   // |histogrammed_thread_task_runner| to detach.
   WaitableEvent top_idle_thread_running(
       WaitableEvent::ResetPolicy::MANUAL,
       WaitableEvent::InitialState::NOT_SIGNALED);
   WaitableEvent top_idle_thread_continue(
       WaitableEvent::ResetPolicy::MANUAL,
       WaitableEvent::InitialState::NOT_SIGNALED);
   auto task_runner_for_top_idle =
       worker_pool_->CreateSequencedTaskRunnerWithTraits(
-          TaskTraits().WithBaseSyncPrimitives());
+          test::CreateTaskTraits().WithBaseSyncPrimitives());
   task_runner_for_top_idle->PostTask(
       FROM_HERE, BindOnce(
                      [](PlatformThreadRef thread_ref,
                         WaitableEvent* top_idle_thread_running,
                         WaitableEvent* top_idle_thread_continue) {
                        ASSERT_FALSE(thread_ref.is_null());
                        EXPECT_NE(thread_ref, PlatformThread::CurrentRef())
                            << "Worker reused. Thread will not detach and the "
                               "histogram value will be wrong.";
                        top_idle_thread_running->Signal();
@@ skipping 60 matching lines @@
       &delayed_task_manager);
   worker_pool->Start(SchedulerWorkerPoolParams(StandbyThreadPolicy::ONE, 8U,
                                                TimeDelta::Max()));
   ASSERT_TRUE(worker_pool);
   EXPECT_EQ(1U, worker_pool->NumberOfAliveWorkersForTesting());
   worker_pool->JoinForTesting();
 }
 
 }  // namespace internal
 }  // namespace base