Use constexpr TaskTraits constructor in base (part 2).

base/task_scheduler/sequence_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/sequence.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/test/gtest_util.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace internal {
 
 namespace {
 
 
 class TaskSchedulerSequenceTest : public testing::Test {
  public:
   TaskSchedulerSequenceTest()
-      : task_a_owned_(
-            new Task(FROM_HERE,
-                     Bind(&DoNothing),
-                     TaskTraits().WithPriority(TaskPriority::BACKGROUND),
-                     TimeDelta())),
-        task_b_owned_(
-            new Task(FROM_HERE,
-                     Bind(&DoNothing),
-                     TaskTraits().WithPriority(TaskPriority::USER_VISIBLE),
-                     TimeDelta())),
-        task_c_owned_(
-            new Task(FROM_HERE,
-                     Bind(&DoNothing),
-                     TaskTraits().WithPriority(TaskPriority::USER_BLOCKING),
-                     TimeDelta())),
-        task_d_owned_(
-            new Task(FROM_HERE,
-                     Bind(&DoNothing),
-                     TaskTraits().WithPriority(TaskPriority::USER_BLOCKING),
-                     TimeDelta())),
-        task_e_owned_(
-            new Task(FROM_HERE,
-                     Bind(&DoNothing),
-                     TaskTraits().WithPriority(TaskPriority::BACKGROUND),
-                     TimeDelta())),
+      : task_a_owned_(new Task(FROM_HERE,
+                               Bind(&DoNothing),
+                               {TaskPriority::BACKGROUND},
+                               TimeDelta())),
+        task_b_owned_(new Task(FROM_HERE,
+                               Bind(&DoNothing),
+                               {TaskPriority::USER_VISIBLE},
+                               TimeDelta())),
+        task_c_owned_(new Task(FROM_HERE,
+                               Bind(&DoNothing),
+                               {TaskPriority::USER_BLOCKING},
+                               TimeDelta())),
+        task_d_owned_(new Task(FROM_HERE,
+                               Bind(&DoNothing),
+                               {TaskPriority::USER_BLOCKING},
+                               TimeDelta())),
+        task_e_owned_(new Task(FROM_HERE,
+                               Bind(&DoNothing),
+                               {TaskPriority::BACKGROUND},
+                               TimeDelta())),
         task_a_(task_a_owned_.get()),
         task_b_(task_b_owned_.get()),
         task_c_(task_c_owned_.get()),
         task_d_(task_d_owned_.get()),
         task_e_(task_e_owned_.get()) {}
 
  protected:
   // Tasks to be handed off to a Sequence for testing.
   std::unique_ptr<Task> task_a_owned_;
   std::unique_ptr<Task> task_b_owned_;
@@ skipping 157 matching lines @@
 }
 
 // Verify that a DCHECK fires if TakeTask() is called on an empty sequence.
 TEST_F(TaskSchedulerSequenceTest, TakeEmptySequence) {
   scoped_refptr<Sequence> sequence(new Sequence);
   EXPECT_DCHECK_DEATH({ sequence->TakeTask(); });
 }
 
 }  // namespace internal
 }  // namespace base