Do not inherit TaskPriority in TaskTraits.

base/task_scheduler/scheduler_worker_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.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task_scheduler/scheduler_lock.h"
 #include "base/task_scheduler/sequence.h"
 #include "base/task_scheduler/task.h"
 #include "base/task_scheduler/task_tracker.h"
+#include "base/task_scheduler/test_utils.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/simple_thread.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_WIN)
 #include <objbase.h>
@@ skipping 133 matching lines @@
 
         // Check if a Sequence should be returned.
         if (outer_->num_sequences_to_create_ == 0)
           return nullptr;
         --outer_->num_sequences_to_create_;
       }
 
       // Create a Sequence with TasksPerSequence() Tasks.
       scoped_refptr<Sequence> sequence(new Sequence);
       for (size_t i = 0; i < outer_->TasksPerSequence(); ++i) {
-        std::unique_ptr<Task> task(
-            new Task(FROM_HERE,
-                     BindOnce(&TaskSchedulerWorkerTest::RunTaskCallback,
-                              Unretained(outer_)),
-                     TaskTraits(), TimeDelta()));
+        auto task =
+            MakeUnique<Task>(FROM_HERE,
+                             BindOnce(&TaskSchedulerWorkerTest::RunTaskCallback,
+                                      Unretained(outer_)),
+                             test::CreateTaskTraits(), TimeDelta());
         EXPECT_TRUE(outer_->task_tracker_.WillPostTask(task.get()));
         sequence->PushTask(std::move(task));
       }
 
       ExpectCallToDidRunTask();
 
       {
         // Add the Sequence to the vector of created Sequences.
         AutoSchedulerLock auto_lock(outer_->lock_);
         outer_->created_sequences_.push_back(sequence);
@@ skipping 243 matching lines @@
       override {
     EXPECT_TRUE(controls_->expect_get_work_);
 
     // Sends one item of work to signal |work_processed_|. On subsequent calls,
     // sends nullptr to indicate there's no more work to be done.
     if (controls_->work_requested_)
       return nullptr;
 
     controls_->work_requested_ = true;
     scoped_refptr<Sequence> sequence(new Sequence);
-    std::unique_ptr<Task> task(new Task(
+    auto task = MakeUnique<Task>(
         FROM_HERE,
         BindOnce(
             [](WaitableEvent* work_processed, WaitableEvent* work_running) {
               work_processed->Signal();
               work_running->Wait();
             },
             Unretained(&controls_->work_processed_),
             Unretained(&controls_->work_running_)),
-        TaskTraits().WithBaseSyncPrimitives().WithShutdownBehavior(
+        test::CreateTaskTraits().WithBaseSyncPrimitives().WithShutdownBehavior(
             TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),
-        TimeDelta()));
+        TimeDelta());
     EXPECT_TRUE(task_tracker_->WillPostTask(task.get()));
     sequence->PushTask(std::move(task));
     return sequence;
   }
 
   void DidRunTask() override {}
 
   bool CanDetach(SchedulerWorker* worker) override {
     // Saving |can_detach_| now so that callers waiting on |detach_requested_|
     // have the thread go to sleep and then allow detachment.
@@ skipping 489 matching lines @@
   // COM library wasn't already initialized on the thread.
   EXPECT_EQ(S_OK, delegate_raw->coinitialize_hresult());
 
   worker->JoinForTesting();
 }
 
 #endif  // defined(OS_WIN)
 
 }  // namespace internal
 }  // namespace base