Use constexpr TaskTraits constructor in base (part 2).

base/task_scheduler/scheduler_single_thread_task_runner_manager_unittest.cc

 // Copyright 2017 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_single_thread_task_runner_manager.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/synchronization/atomic_flag.h"
 #include "base/synchronization/lock.h"
@@ skipping 75 matching lines @@
   ADD_FAILURE() << "Ran a task that shouldn't run.";
 }
 
 }  // namespace
 
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, DifferentThreadsUsed) {
   scoped_refptr<SingleThreadTaskRunner> task_runner_1 =
       single_thread_task_runner_manager_
           ->CreateSingleThreadTaskRunnerWithTraits(
               "A", ThreadPriority::NORMAL,
-              TaskTraits().WithShutdownBehavior(
-                  TaskShutdownBehavior::BLOCK_SHUTDOWN));
+              {TaskShutdownBehavior::BLOCK_SHUTDOWN});
   scoped_refptr<SingleThreadTaskRunner> task_runner_2 =
       single_thread_task_runner_manager_
           ->CreateSingleThreadTaskRunnerWithTraits(
               "B", ThreadPriority::NORMAL,
-              TaskTraits().WithShutdownBehavior(
-                  TaskShutdownBehavior::BLOCK_SHUTDOWN));
+              {TaskShutdownBehavior::BLOCK_SHUTDOWN});
 
   PlatformThreadRef thread_ref_1;
   task_runner_1->PostTask(FROM_HERE,
                           BindOnce(&CaptureThreadRef, &thread_ref_1));
   PlatformThreadRef thread_ref_2;
   task_runner_2->PostTask(FROM_HERE,
                           BindOnce(&CaptureThreadRef, &thread_ref_2));
 
   task_tracker_.Shutdown();
 
   ASSERT_FALSE(thread_ref_1.is_null());
   ASSERT_FALSE(thread_ref_2.is_null());
   EXPECT_NE(thread_ref_1, thread_ref_2);
 }
 
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, PrioritySetCorrectly) {
   // Why are events used here instead of the task tracker?
   // Shutting down can cause priorities to get raised. This means we have to use
   // events to determine when a task is run.
   scoped_refptr<SingleThreadTaskRunner> task_runner_background =
       single_thread_task_runner_manager_
-          ->CreateSingleThreadTaskRunnerWithTraits(
-              "Background", ThreadPriority::BACKGROUND,
-              TaskTraits().WithPriority(TaskPriority::BACKGROUND));
+          ->CreateSingleThreadTaskRunnerWithTraits("Background",
+                                                   ThreadPriority::BACKGROUND,
+                                                   {TaskPriority::BACKGROUND});
   scoped_refptr<SingleThreadTaskRunner> task_runner_normal =
       single_thread_task_runner_manager_
           ->CreateSingleThreadTaskRunnerWithTraits(
-              "Normal", ThreadPriority::NORMAL,
-              TaskTraits().WithPriority(TaskPriority::USER_VISIBLE));
+              "Normal", ThreadPriority::NORMAL, {TaskPriority::USER_VISIBLE});
 
   ThreadPriority thread_priority_background;
   task_runner_background->PostTask(
       FROM_HERE, BindOnce(&CaptureThreadPriority, &thread_priority_background));
   WaitableEvent waitable_event_background(
       WaitableEvent::ResetPolicy::MANUAL,
       WaitableEvent::InitialState::NOT_SIGNALED);
   task_runner_background->PostTask(
       FROM_HERE,
       BindOnce(&WaitableEvent::Signal, Unretained(&waitable_event_background)));
@@ skipping 50 matching lines @@
   EXPECT_LT(actual_delay,
             TimeDelta::FromMilliseconds(250) + TestTimeouts::tiny_timeout());
 }
 
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest,
        RunsTasksOnCurrentThread) {
   scoped_refptr<SingleThreadTaskRunner> task_runner_1 =
       single_thread_task_runner_manager_
           ->CreateSingleThreadTaskRunnerWithTraits(
               "A", ThreadPriority::NORMAL,
-              TaskTraits().WithShutdownBehavior(
-                  TaskShutdownBehavior::BLOCK_SHUTDOWN));
+              {TaskShutdownBehavior::BLOCK_SHUTDOWN});
   scoped_refptr<SingleThreadTaskRunner> task_runner_2 =
       single_thread_task_runner_manager_
           ->CreateSingleThreadTaskRunnerWithTraits(
               "B", ThreadPriority::NORMAL,
-              TaskTraits().WithShutdownBehavior(
-                  TaskShutdownBehavior::BLOCK_SHUTDOWN));
+              {TaskShutdownBehavior::BLOCK_SHUTDOWN});
 
   EXPECT_FALSE(task_runner_1->RunsTasksOnCurrentThread());
   EXPECT_FALSE(task_runner_2->RunsTasksOnCurrentThread());
 
   task_runner_1->PostTask(
       FROM_HERE, BindOnce(
                      [](scoped_refptr<SingleThreadTaskRunner> task_runner_1,
                         scoped_refptr<SingleThreadTaskRunner> task_runner_2) {
                        EXPECT_TRUE(task_runner_1->RunsTasksOnCurrentThread());
                        EXPECT_FALSE(task_runner_2->RunsTasksOnCurrentThread());
@@ skipping 59 matching lines @@
 
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerJoinTest, ConcurrentJoin) {
   // Exercises the codepath where the workers are unavailable for unregistration
   // because of a Join call.
   WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL,
                              WaitableEvent::InitialState::NOT_SIGNALED);
   WaitableEvent task_blocking(WaitableEvent::ResetPolicy::MANUAL,
                               WaitableEvent::InitialState::NOT_SIGNALED);
 
   {
-    auto task_runner = single_thread_task_runner_manager_
-                           ->CreateSingleThreadTaskRunnerWithTraits(
-                               "A", ThreadPriority::NORMAL,
-                               TaskTraits().WithBaseSyncPrimitives());
+    auto task_runner =
+        single_thread_task_runner_manager_
+            ->CreateSingleThreadTaskRunnerWithTraits(
+                "A", ThreadPriority::NORMAL, {WithBaseSyncPrimitives()});
     EXPECT_TRUE(task_runner->PostTask(
         FROM_HERE,
         BindOnce(&WaitableEvent::Signal, Unretained(&task_running))));
     EXPECT_TRUE(task_runner->PostTask(
         FROM_HERE, BindOnce(&WaitableEvent::Wait, Unretained(&task_blocking))));
   }
 
   task_running.Wait();
   CallJoinFromDifferentThread join_from_different_thread(
       single_thread_task_runner_manager_.get());
   join_from_different_thread.Start();
   join_from_different_thread.WaitForRunToStart();
   task_blocking.Signal();
   join_from_different_thread.Join();
 }
 
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerJoinTest,
        ConcurrentJoinExtraSkippedTask) {
   // Tests to make sure that tasks are properly cleaned up at Join, allowing
   // SingleThreadTaskRunners to unregister themselves.
   WaitableEvent task_running(WaitableEvent::ResetPolicy::MANUAL,
                              WaitableEvent::InitialState::NOT_SIGNALED);
   WaitableEvent task_blocking(WaitableEvent::ResetPolicy::MANUAL,
                               WaitableEvent::InitialState::NOT_SIGNALED);
 
   {
-    auto task_runner = single_thread_task_runner_manager_
-                           ->CreateSingleThreadTaskRunnerWithTraits(
-                               "A", ThreadPriority::NORMAL,
-                               TaskTraits().WithBaseSyncPrimitives());
+    auto task_runner =
+        single_thread_task_runner_manager_
+            ->CreateSingleThreadTaskRunnerWithTraits(
+                "A", ThreadPriority::NORMAL, {WithBaseSyncPrimitives()});
     EXPECT_TRUE(task_runner->PostTask(
         FROM_HERE,
         BindOnce(&WaitableEvent::Signal, Unretained(&task_running))));
     EXPECT_TRUE(task_runner->PostTask(
         FROM_HERE, BindOnce(&WaitableEvent::Wait, Unretained(&task_blocking))));
     EXPECT_TRUE(task_runner->PostTask(FROM_HERE, BindOnce(&DoNothing)));
   }
 
   task_running.Wait();
   CallJoinFromDifferentThread join_from_different_thread(
       single_thread_task_runner_manager_.get());
   join_from_different_thread.Start();
   join_from_different_thread.WaitForRunToStart();
   task_blocking.Signal();
   join_from_different_thread.Join();
 }
 
 #if defined(OS_WIN)
 
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTest, COMSTAInitialized) {
   scoped_refptr<SingleThreadTaskRunner> com_task_runner =
       single_thread_task_runner_manager_->CreateCOMSTATaskRunnerWithTraits(
-          "A", ThreadPriority::NORMAL,
-          TaskTraits().WithShutdownBehavior(
-              TaskShutdownBehavior::BLOCK_SHUTDOWN));
+          "A", ThreadPriority::NORMAL, {TaskShutdownBehavior::BLOCK_SHUTDOWN});
 
   com_task_runner->PostTask(
       FROM_HERE, BindOnce([]() {
         HRESULT hr = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
         if (SUCCEEDED(hr)) {
           ADD_FAILURE() << "COM STA was not initialized on this thread";
           CoUninitialize();
         }
       }));
 
@@ skipping 41 matching lines @@
   bool register_class_succeeded_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(TaskSchedulerSingleThreadTaskRunnerManagerTestWin);
 };
 
 }  // namespace
 
 TEST_F(TaskSchedulerSingleThreadTaskRunnerManagerTestWin, PumpsMessages) {
   scoped_refptr<SingleThreadTaskRunner> com_task_runner =
       single_thread_task_runner_manager_->CreateCOMSTATaskRunnerWithTraits(
-          "A", ThreadPriority::NORMAL,
-          TaskTraits().WithShutdownBehavior(
-              TaskShutdownBehavior::BLOCK_SHUTDOWN));
+          "A", ThreadPriority::NORMAL, {TaskShutdownBehavior::BLOCK_SHUTDOWN});
   HWND hwnd = nullptr;
   // HWNDs process messages on the thread that created them, so we have to
   // create them within the context of the task runner to properly simulate a
   // COM callback.
   com_task_runner->PostTask(
       FROM_HERE,
       BindOnce(
           [](TaskSchedulerSingleThreadTaskRunnerManagerTestWin* test_harness,
              HWND* hwnd) { *hwnd = test_harness->CreateTestWindow(); },
           Unretained(this), &hwnd));
@@ skipping 57 matching lines @@
   PlatformThread::Sleep(TestTimeouts::tiny_timeout());
   manager_started.Set();
   single_thread_task_runner_manager_->Start();
 
   // This should not hang if the task is scheduled after Start().
   task_running.Wait();
 }
 
 }  // namespace internal
 }  // namespace base