Use constexpr TaskTraits constructor in base (part 2).

base/task_scheduler/task_scheduler_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/task_scheduler_impl.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 157 matching lines @@
 
   const test::ExecutionMode execution_modes[] = {
       test::ExecutionMode::PARALLEL, test::ExecutionMode::SEQUENCED,
       test::ExecutionMode::SINGLE_THREADED};
 
   for (test::ExecutionMode execution_mode : execution_modes) {
     for (size_t priority_index = static_cast<size_t>(TaskPriority::LOWEST);
          priority_index <= static_cast<size_t>(TaskPriority::HIGHEST);
          ++priority_index) {
       const TaskPriority priority = static_cast<TaskPriority>(priority_index);
-      params.push_back(TraitsExecutionModePair(
-          TaskTraits().WithPriority(priority), execution_mode));
-      params.push_back(TraitsExecutionModePair(
-          TaskTraits().WithPriority(priority).MayBlock(), execution_mode));
+      params.push_back(TraitsExecutionModePair({priority}, execution_mode));
+      params.push_back(TraitsExecutionModePair({MayBlock()}, execution_mode));
     }
   }
 
   return params;
 }
 
 class TaskSchedulerImplTest
     : public testing::TestWithParam<TraitsExecutionModePair> {
  protected:
   TaskSchedulerImplTest() : scheduler_("Test") {}
@@ skipping 169 matching lines @@
 
   for (const auto& thread : threads_posting_tasks) {
     thread->WaitForAllTasksToRun();
     thread->Join();
   }
 }
 
 TEST_F(TaskSchedulerImplTest, GetMaxConcurrentTasksWithTraitsDeprecated) {
   StartTaskScheduler();
   EXPECT_EQ(1, scheduler_.GetMaxConcurrentTasksWithTraitsDeprecated(
-                   TaskTraits().WithPriority(TaskPriority::BACKGROUND)));
-  EXPECT_EQ(
-      3, scheduler_.GetMaxConcurrentTasksWithTraitsDeprecated(
-             TaskTraits().WithPriority(TaskPriority::BACKGROUND).MayBlock()));
+                   {TaskPriority::BACKGROUND}));
+  EXPECT_EQ(3, scheduler_.GetMaxConcurrentTasksWithTraitsDeprecated(
+                   {MayBlock(), TaskPriority::BACKGROUND}));
   EXPECT_EQ(4, scheduler_.GetMaxConcurrentTasksWithTraitsDeprecated(
-                   TaskTraits().WithPriority(TaskPriority::USER_VISIBLE)));
-  EXPECT_EQ(
-      12,
-      scheduler_.GetMaxConcurrentTasksWithTraitsDeprecated(
-          TaskTraits().WithPriority(TaskPriority::USER_VISIBLE).MayBlock()));
+                   {TaskPriority::USER_VISIBLE}));
+  EXPECT_EQ(12, scheduler_.GetMaxConcurrentTasksWithTraitsDeprecated(
+                    {MayBlock(), TaskPriority::USER_VISIBLE}));
   EXPECT_EQ(4, scheduler_.GetMaxConcurrentTasksWithTraitsDeprecated(
-                   TaskTraits().WithPriority(TaskPriority::USER_BLOCKING)));
-  EXPECT_EQ(
-      12,
-      scheduler_.GetMaxConcurrentTasksWithTraitsDeprecated(
-          TaskTraits().WithPriority(TaskPriority::USER_BLOCKING).MayBlock()));
+                   {TaskPriority::USER_BLOCKING}));
+  EXPECT_EQ(12, scheduler_.GetMaxConcurrentTasksWithTraitsDeprecated(
+                    {MayBlock(), TaskPriority::USER_BLOCKING}));
 }
 
 // Verify that the RunsTasksOnCurrentThread() method of a SequencedTaskRunner
 // returns false when called from a task that isn't part of the sequence.
 TEST_F(TaskSchedulerImplTest, SequencedRunsTasksOnCurrentThread) {
   StartTaskScheduler();
   auto single_thread_task_runner =
       scheduler_.CreateSingleThreadTaskRunnerWithTraits(TaskTraits());
   auto sequenced_task_runner =
       scheduler_.CreateSequencedTaskRunnerWithTraits(TaskTraits());
@@ skipping 84 matching lines @@
 #if defined(OS_POSIX)
 
 TEST_F(TaskSchedulerImplTest, FileDescriptorWatcherNoOpsAfterShutdown) {
   StartTaskScheduler();
 
   int pipes[2];
   ASSERT_EQ(0, pipe(pipes));
 
   scoped_refptr<TaskRunner> blocking_task_runner =
       scheduler_.CreateSequencedTaskRunnerWithTraits(
-          TaskTraits().WithShutdownBehavior(
-              TaskShutdownBehavior::BLOCK_SHUTDOWN));
+          {TaskShutdownBehavior::BLOCK_SHUTDOWN});
   blocking_task_runner->PostTask(
       FROM_HERE,
       BindOnce(
           [](int read_fd) {
             std::unique_ptr<FileDescriptorWatcher::Controller> controller =
                 FileDescriptorWatcher::WatchReadable(
                     read_fd, BindRepeating([]() { NOTREACHED(); }));
 
             // This test is for components that intentionally leak their
             // watchers at shutdown. We can't clean |controller| up because its
@@ skipping 18 matching lines @@
   // Give a chance for the file watcher to fire before closing the handles.
   PlatformThread::Sleep(TestTimeouts::tiny_timeout());
 
   EXPECT_EQ(0, IGNORE_EINTR(close(pipes[0])));
   EXPECT_EQ(0, IGNORE_EINTR(close(pipes[1])));
 }
 #endif  // defined(OS_POSIX)
 
 }  // namespace internal
 }  // namespace base