Do not inherit TaskPriority in TaskTraits.

base/task_scheduler/delayed_task_manager_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/delayed_task_manager.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/task_scheduler/task.h"
+#include "base/task_scheduler/test_utils.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/time/time.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace internal {
 namespace {
 
 constexpr TimeDelta kLongDelay = TimeDelta::FromHours(1);
@@ skipping 17 matching lines @@
 
 class TaskSchedulerDelayedTaskManagerTest : public testing::Test {
  public:
   TaskSchedulerDelayedTaskManagerTest()
       : delayed_task_manager_(service_thread_task_runner_->GetMockTickClock()) {
   }
   ~TaskSchedulerDelayedTaskManagerTest() override = default;
 
  protected:
   std::unique_ptr<Task> CreateTask(TimeDelta delay) {
-    auto task =
-        MakeUnique<Task>(FROM_HERE, BindOnce(&DoNothing), TaskTraits(), delay);
+    auto task = MakeUnique<Task>(FROM_HERE, BindOnce(&DoNothing),
+                                 test::CreateTaskTraits(), delay);
 
     // The constructor of Task computes |delayed_run_time| by adding |delay| to
     // the real time. Recompute it by adding |delay| to the mock time.
     task->delayed_run_time =
         service_thread_task_runner_->GetMockTickClock()->NowTicks() + delay;
 
     return task;
   }
 
   testing::StrictMock<MockTaskTarget> task_target_;
@@ skipping 95 matching lines @@
 
   // Fast-forward time. Expect the task is forwarded to |task_target_|.
   EXPECT_CALL(task_target_, DoPostTaskNowCallback(task_raw_));
   service_thread_task_runner_->FastForwardBy(kLongDelay);
 }
 
 // Verify that multiple delayed tasks added after Start() are forwarded when
 // they are ripe for execution.
 TEST_F(TaskSchedulerDelayedTaskManagerTest, DelayedTasksRunAfterDelay) {
   delayed_task_manager_.Start(service_thread_task_runner_);
-  auto task_a = MakeUnique<Task>(FROM_HERE, BindOnce(&DoNothing), TaskTraits(),
-                                 TimeDelta::FromHours(1));
+  auto task_a =
+      MakeUnique<Task>(FROM_HERE, BindOnce(&DoNothing),
+                       test::CreateTaskTraits(), TimeDelta::FromHours(1));
   const Task* task_a_raw = task_a.get();
 
-  auto task_b = MakeUnique<Task>(FROM_HERE, BindOnce(&DoNothing), TaskTraits(),
-                                 TimeDelta::FromHours(2));
+  auto task_b =
+      MakeUnique<Task>(FROM_HERE, BindOnce(&DoNothing),
+                       test::CreateTaskTraits(), TimeDelta::FromHours(2));
   const Task* task_b_raw = task_b.get();
 
-  auto task_c = MakeUnique<Task>(FROM_HERE, BindOnce(&DoNothing), TaskTraits(),
-                                 TimeDelta::FromHours(1));
+  auto task_c =
+      MakeUnique<Task>(FROM_HERE, BindOnce(&DoNothing),
+                       test::CreateTaskTraits(), TimeDelta::FromHours(1));
   const Task* task_c_raw = task_c.get();
 
   // Send tasks to the DelayedTaskManager.
   delayed_task_manager_.AddDelayedTask(
       std::move(task_a), BindOnce(&MockTaskTarget::PostTaskNowCallback,
                                   Unretained(&task_target_)));
   delayed_task_manager_.AddDelayedTask(
       std::move(task_b), BindOnce(&MockTaskTarget::PostTaskNowCallback,
                                   Unretained(&task_target_)));
   delayed_task_manager_.AddDelayedTask(
@@ skipping 12 matching lines @@
   testing::Mock::VerifyAndClear(&task_target_);
 
   // Fast-forward time. Expect |task_b_raw| to be forwarded to |task_target_|.
   EXPECT_CALL(task_target_, DoPostTaskNowCallback(task_b_raw));
   service_thread_task_runner_->FastForwardBy(TimeDelta::FromHours(1));
   testing::Mock::VerifyAndClear(&task_target_);
 }
 
 }  // namespace internal
 }  // namespace base