Use constexpr TaskTraits constructor in base (part 2).

base/task_scheduler/task_tracker_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_tracker.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 131 matching lines @@
 class TaskSchedulerTaskTrackerTest
     : public testing::TestWithParam<TaskShutdownBehavior> {
  protected:
   TaskSchedulerTaskTrackerTest() = default;
 
   // Creates a task with |shutdown_behavior|.
   std::unique_ptr<Task> CreateTask(TaskShutdownBehavior shutdown_behavior) {
     return MakeUnique<Task>(
         FROM_HERE,
         Bind(&TaskSchedulerTaskTrackerTest::RunTaskCallback, Unretained(this)),
-        TaskTraits().WithShutdownBehavior(shutdown_behavior), TimeDelta());
+        TaskTraits(shutdown_behavior), TimeDelta());
   }
 
   // Calls tracker_->Shutdown() on a new thread. When this returns, Shutdown()
   // method has been entered on the new thread, but it hasn't necessarily
   // returned.
   void CallShutdownAsync() {
     ASSERT_FALSE(thread_calling_shutdown_);
     thread_calling_shutdown_.reset(new CallbackThread(
         Bind(&TaskTracker::Shutdown, Unretained(&tracker_))));
     thread_calling_shutdown_->Start();
@@ skipping 99 matching lines @@
   tracker_.Shutdown();
 }
 
 TEST_P(TaskSchedulerTaskTrackerTest, WillPostAndRunLongTaskBeforeShutdown) {
   // Create a task that signals |task_running| and blocks until |task_barrier|
   // is signaled.
   WaitableEvent task_running(WaitableEvent::ResetPolicy::AUTOMATIC,
                              WaitableEvent::InitialState::NOT_SIGNALED);
   WaitableEvent task_barrier(WaitableEvent::ResetPolicy::AUTOMATIC,
                              WaitableEvent::InitialState::NOT_SIGNALED);
-  auto blocked_task = base::MakeUnique<Task>(
+  auto blocked_task = MakeUnique<Task>(
       FROM_HERE,
       Bind(
           [](WaitableEvent* task_running, WaitableEvent* task_barrier) {
             task_running->Signal();
             task_barrier->Wait();
           },
-          Unretained(&task_running), base::Unretained(&task_barrier)),
-      TaskTraits().WithBaseSyncPrimitives().WithShutdownBehavior(GetParam()),
-      TimeDelta());
+          Unretained(&task_running), Unretained(&task_barrier)),
+      TaskTraits(WithBaseSyncPrimitives(), GetParam()), TimeDelta());
 
   // Inform |task_tracker_| that |blocked_task| will be posted.
   EXPECT_TRUE(tracker_.WillPostTask(blocked_task.get()));
 
   // Create a thread to run the task. Wait until the task starts running.
   ThreadPostingAndRunningTask thread_running_task(
       &tracker_, std::move(blocked_task),
       ThreadPostingAndRunningTask::Action::RUN, false);
   thread_running_task.Start();
   task_running.Wait();
@@ skipping 130 matching lines @@
 
 // Verify that BLOCK_SHUTDOWN and SKIP_ON_SHUTDOWN tasks can
 // AssertSingletonAllowed() but CONTINUE_ON_SHUTDOWN tasks can't.
 TEST_P(TaskSchedulerTaskTrackerTest, SingletonAllowed) {
   const bool can_use_singletons =
       (GetParam() != TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN);
 
   TaskTracker tracker;
   std::unique_ptr<Task> task(
       new Task(FROM_HERE, BindOnce(&ThreadRestrictions::AssertSingletonAllowed),
-               TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta()));
+               TaskTraits(GetParam()), TimeDelta()));
   EXPECT_TRUE(tracker.WillPostTask(task.get()));
 
   // Set the singleton allowed bit to the opposite of what it is expected to be
   // when |tracker| runs |task| to verify that |tracker| actually sets the
   // correct value.
   ScopedSetSingletonAllowed scoped_singleton_allowed(!can_use_singletons);
 
   // Running the task should fail iff the task isn't allowed to use singletons.
   if (can_use_singletons) {
     EXPECT_TRUE(tracker.RunTask(std::move(task), SequenceToken::Create()));
   } else {
     EXPECT_DCHECK_DEATH(
         { tracker.RunTask(std::move(task), SequenceToken::Create()); });
   }
 }
 
 // Verify that AssertIOAllowed() succeeds only for a MayBlock() task.
 TEST_P(TaskSchedulerTaskTrackerTest, IOAllowed) {
   TaskTracker tracker;
 
   // Unset the IO allowed bit. Expect TaskTracker to set it before running a
   // task with the MayBlock() trait.
   ThreadRestrictions::SetIOAllowed(false);
-  auto task_with_may_block = MakeUnique<Task>(
-      FROM_HERE, Bind([]() {
-        // Shouldn't fail.
-        ThreadRestrictions::AssertIOAllowed();
-      }),
-      TaskTraits().MayBlock().WithShutdownBehavior(GetParam()), TimeDelta());
+  auto task_with_may_block =
+      MakeUnique<Task>(FROM_HERE, Bind([]() {
+                         // Shouldn't fail.
+                         ThreadRestrictions::AssertIOAllowed();
+                       }),
+                       TaskTraits(MayBlock(), GetParam()), TimeDelta());
   EXPECT_TRUE(tracker.WillPostTask(task_with_may_block.get()));
   tracker.RunTask(std::move(task_with_may_block), SequenceToken::Create());
 
   // Set the IO allowed bit. Expect TaskTracker to unset it before running a
   // task without the MayBlock() trait.
   ThreadRestrictions::SetIOAllowed(true);
   auto task_without_may_block = MakeUnique<Task>(
       FROM_HERE, Bind([]() {
         EXPECT_DCHECK_DEATH({ ThreadRestrictions::AssertIOAllowed(); });
       }),
-      TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta());
+      TaskTraits(GetParam()), TimeDelta());
   EXPECT_TRUE(tracker.WillPostTask(task_without_may_block.get()));
   tracker.RunTask(std::move(task_without_may_block), SequenceToken::Create());
 }
 
 static void RunTaskRunnerHandleVerificationTask(
     TaskTracker* tracker,
     std::unique_ptr<Task> verify_task) {
   // Pretend |verify_task| is posted to respect TaskTracker's contract.
   EXPECT_TRUE(tracker->WillPostTask(verify_task.get()));
 
@@ skipping 13 matching lines @@
 static void VerifyNoTaskRunnerHandle() {
   EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
   EXPECT_FALSE(SequencedTaskRunnerHandle::IsSet());
 }
 
 TEST_P(TaskSchedulerTaskTrackerTest, TaskRunnerHandleIsNotSetOnParallel) {
   // Create a task that will verify that TaskRunnerHandles are not set in its
   // scope per no TaskRunner ref being set to it.
   std::unique_ptr<Task> verify_task(
       new Task(FROM_HERE, BindOnce(&VerifyNoTaskRunnerHandle),
-               TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta()));
+               TaskTraits(GetParam()), TimeDelta()));
 
   RunTaskRunnerHandleVerificationTask(&tracker_, std::move(verify_task));
 }
 
 static void VerifySequencedTaskRunnerHandle(
     const SequencedTaskRunner* expected_task_runner) {
   EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
   EXPECT_TRUE(SequencedTaskRunnerHandle::IsSet());
   EXPECT_EQ(expected_task_runner, SequencedTaskRunnerHandle::Get());
 }
 
 TEST_P(TaskSchedulerTaskTrackerTest,
        SequencedTaskRunnerHandleIsSetOnSequenced) {
   scoped_refptr<SequencedTaskRunner> test_task_runner(new TestSimpleTaskRunner);
 
   // Create a task that will verify that SequencedTaskRunnerHandle is properly
   // set to |test_task_runner| in its scope per |sequenced_task_runner_ref|
   // being set to it.
   std::unique_ptr<Task> verify_task(
       new Task(FROM_HERE,
                BindOnce(&VerifySequencedTaskRunnerHandle,
-                        base::Unretained(test_task_runner.get())),
-               TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta()));
+                        Unretained(test_task_runner.get())),
+               TaskTraits(GetParam()), TimeDelta()));
   verify_task->sequenced_task_runner_ref = test_task_runner;
 
   RunTaskRunnerHandleVerificationTask(&tracker_, std::move(verify_task));
 }
 
 static void VerifyThreadTaskRunnerHandle(
     const SingleThreadTaskRunner* expected_task_runner) {
   EXPECT_TRUE(ThreadTaskRunnerHandle::IsSet());
   // SequencedTaskRunnerHandle inherits ThreadTaskRunnerHandle for thread.
   EXPECT_TRUE(SequencedTaskRunnerHandle::IsSet());
   EXPECT_EQ(expected_task_runner, ThreadTaskRunnerHandle::Get());
 }
 
 TEST_P(TaskSchedulerTaskTrackerTest,
        ThreadTaskRunnerHandleIsSetOnSingleThreaded) {
   scoped_refptr<SingleThreadTaskRunner> test_task_runner(
       new TestSimpleTaskRunner);
 
   // Create a task that will verify that ThreadTaskRunnerHandle is properly set
   // to |test_task_runner| in its scope per |single_thread_task_runner_ref|
   // being set on it.
   std::unique_ptr<Task> verify_task(
       new Task(FROM_HERE,
                BindOnce(&VerifyThreadTaskRunnerHandle,
-                        base::Unretained(test_task_runner.get())),
-               TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta()));
+                        Unretained(test_task_runner.get())),
+               TaskTraits(GetParam()), TimeDelta()));
   verify_task->single_thread_task_runner_ref = test_task_runner;
 
   RunTaskRunnerHandleVerificationTask(&tracker_, std::move(verify_task));
 }
 
 TEST_P(TaskSchedulerTaskTrackerTest, FlushPendingDelayedTask) {
   const Task delayed_task(FROM_HERE, BindOnce(&DoNothing),
-                          TaskTraits().WithShutdownBehavior(GetParam()),
-                          TimeDelta::FromDays(1));
+                          TaskTraits(GetParam()), TimeDelta::FromDays(1));
   tracker_.WillPostTask(&delayed_task);
   // Flush() should return even if the delayed task didn't run.
   tracker_.Flush();
 }
 
 TEST_P(TaskSchedulerTaskTrackerTest, FlushPendingUndelayedTask) {
-  auto undelayed_task = base::MakeUnique<Task>(
-      FROM_HERE, Bind(&DoNothing),
-      TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta());
+  auto undelayed_task = MakeUnique<Task>(FROM_HERE, Bind(&DoNothing),
+                                         TaskTraits(GetParam()), TimeDelta());
   tracker_.WillPostTask(undelayed_task.get());
 
   // Flush() shouldn't return before the undelayed task runs.
   CallFlushAsync();
   PlatformThread::Sleep(TestTimeouts::tiny_timeout());
   VERIFY_ASYNC_FLUSH_IN_PROGRESS();
 
   // Flush() should return after the undelayed task runs.
   tracker_.RunTask(std::move(undelayed_task), SequenceToken::Create());
   WAIT_FOR_ASYNC_FLUSH_RETURNED();
 }
 
 TEST_P(TaskSchedulerTaskTrackerTest, PostTaskDuringFlush) {
-  auto undelayed_task = base::MakeUnique<Task>(
-      FROM_HERE, Bind(&DoNothing),
-      TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta());
+  auto undelayed_task = MakeUnique<Task>(FROM_HERE, Bind(&DoNothing),
+                                         TaskTraits(GetParam()), TimeDelta());
   tracker_.WillPostTask(undelayed_task.get());
 
   // Flush() shouldn't return before the undelayed task runs.
   CallFlushAsync();
   PlatformThread::Sleep(TestTimeouts::tiny_timeout());
   VERIFY_ASYNC_FLUSH_IN_PROGRESS();
 
   // Simulate posting another undelayed task.
-  auto other_undelayed_task = base::MakeUnique<Task>(
-      FROM_HERE, Bind(&DoNothing),
-      TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta());
+  auto other_undelayed_task = MakeUnique<Task>(
+      FROM_HERE, Bind(&DoNothing), TaskTraits(GetParam()), TimeDelta());
   tracker_.WillPostTask(other_undelayed_task.get());
 
   // Run the first undelayed task.
   tracker_.RunTask(std::move(undelayed_task), SequenceToken::Create());
 
   // Flush() shouldn't return before the second undelayed task runs.
   PlatformThread::Sleep(TestTimeouts::tiny_timeout());
   VERIFY_ASYNC_FLUSH_IN_PROGRESS();
 
   // Flush() should return after the second undelayed task runs.
   tracker_.RunTask(std::move(other_undelayed_task), SequenceToken::Create());
   WAIT_FOR_ASYNC_FLUSH_RETURNED();
 }
 
 TEST_P(TaskSchedulerTaskTrackerTest, RunDelayedTaskDuringFlush) {
   // Simulate posting a delayed and an undelayed task.
-  auto delayed_task = base::MakeUnique<Task>(
-      FROM_HERE, Bind(&DoNothing),
-      TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta::FromDays(1));
+  auto delayed_task =
+      MakeUnique<Task>(FROM_HERE, Bind(&DoNothing), TaskTraits(GetParam()),
+                       TimeDelta::FromDays(1));
   tracker_.WillPostTask(delayed_task.get());
-  auto undelayed_task = base::MakeUnique<Task>(
-      FROM_HERE, Bind(&DoNothing),
-      TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta());
+  auto undelayed_task = MakeUnique<Task>(FROM_HERE, Bind(&DoNothing),
+                                         TaskTraits(GetParam()), TimeDelta());
   tracker_.WillPostTask(undelayed_task.get());
 
   // Flush() shouldn't return before the undelayed task runs.
   CallFlushAsync();
   PlatformThread::Sleep(TestTimeouts::tiny_timeout());
   VERIFY_ASYNC_FLUSH_IN_PROGRESS();
 
   // Run the delayed task.
   tracker_.RunTask(std::move(delayed_task), SequenceToken::Create());
 
   // Flush() shouldn't return since there is still a pending undelayed
   // task.
   PlatformThread::Sleep(TestTimeouts::tiny_timeout());
   VERIFY_ASYNC_FLUSH_IN_PROGRESS();
 
   // Run the undelayed task.
   tracker_.RunTask(std::move(undelayed_task), SequenceToken::Create());
 
   // Flush() should now return.
   WAIT_FOR_ASYNC_FLUSH_RETURNED();
 }
 
 TEST_P(TaskSchedulerTaskTrackerTest, FlushAfterShutdown) {
   if (GetParam() == TaskShutdownBehavior::BLOCK_SHUTDOWN)
     return;
 
   // Simulate posting a task.
-  auto undelayed_task = base::MakeUnique<Task>(
-      FROM_HERE, Bind(&DoNothing),
-      TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta());
+  auto undelayed_task = MakeUnique<Task>(FROM_HERE, Bind(&DoNothing),
+                                         TaskTraits(GetParam()), TimeDelta());
   tracker_.WillPostTask(undelayed_task.get());
 
   // Shutdown() should return immediately since there are no pending
   // BLOCK_SHUTDOWN tasks.
   tracker_.Shutdown();
 
   // Flush() should return immediately after shutdown, even if an
   // undelayed task hasn't run.
   tracker_.Flush();
 }
 
 TEST_P(TaskSchedulerTaskTrackerTest, ShutdownDuringFlush) {
   if (GetParam() == TaskShutdownBehavior::BLOCK_SHUTDOWN)
     return;
 
   // Simulate posting a task.
-  auto undelayed_task = base::MakeUnique<Task>(
-      FROM_HERE, Bind(&DoNothing),
-      TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta());
+  auto undelayed_task = MakeUnique<Task>(FROM_HERE, Bind(&DoNothing),
+                                         TaskTraits(GetParam()), TimeDelta());
   tracker_.WillPostTask(undelayed_task.get());
 
   // Flush() shouldn't return before the undelayed task runs or
   // shutdown completes.
   CallFlushAsync();
   PlatformThread::Sleep(TestTimeouts::tiny_timeout());
   VERIFY_ASYNC_FLUSH_IN_PROGRESS();
 
   // Shutdown() should return immediately since there are no pending
   // BLOCK_SHUTDOWN tasks.
@@ skipping 21 matching lines @@
 void ExpectSequenceToken(SequenceToken sequence_token) {
   EXPECT_EQ(sequence_token, SequenceToken::GetForCurrentThread());
 }
 
 }  // namespace
 
 // Verify that SequenceToken::GetForCurrentThread() returns the Sequence's token
 // when a Task runs.
 TEST_F(TaskSchedulerTaskTrackerTest, CurrentSequenceToken) {
   const SequenceToken sequence_token(SequenceToken::Create());
-  auto task = base::MakeUnique<Task>(FROM_HERE,
-                                     Bind(&ExpectSequenceToken, sequence_token),
-                                     TaskTraits(), TimeDelta());
+  auto task =
+      MakeUnique<Task>(FROM_HERE, Bind(&ExpectSequenceToken, sequence_token),
+                       TaskTraits(), TimeDelta());
   tracker_.WillPostTask(task.get());
 
   EXPECT_FALSE(SequenceToken::GetForCurrentThread().IsValid());
   EXPECT_TRUE(tracker_.RunTask(std::move(task), sequence_token));
   EXPECT_FALSE(SequenceToken::GetForCurrentThread().IsValid());
 }
 
 TEST_F(TaskSchedulerTaskTrackerTest, LoadWillPostAndRunBeforeShutdown) {
   // Post and run tasks asynchronously.
   std::vector<std::unique_ptr<ThreadPostingAndRunningTask>> threads;
@@ skipping 145 matching lines @@
                     SequenceToken::Create());
 
     // Disallow waiting. Expect TaskTracker to allow it before running a task
     // with the WithBaseSyncPrimitives() trait.
     ThreadRestrictions::DisallowWaiting();
     auto task_with_sync_primitives =
         MakeUnique<Task>(FROM_HERE, Bind([]() {
                            // Shouldn't fail.
                            ThreadRestrictions::AssertWaitAllowed();
                          }),
-                         TaskTraits().WithBaseSyncPrimitives(), TimeDelta());
+                         TaskTraits(WithBaseSyncPrimitives()), TimeDelta());
     EXPECT_TRUE(tracker.WillPostTask(task_with_sync_primitives.get()));
     tracker.RunTask(std::move(task_with_sync_primitives),
                     SequenceToken::Create());
   }
 
   DISALLOW_COPY_AND_ASSIGN(WaitAllowedTestThread);
 };
 
 }  // namespace
 
@@ skipping 12 matching lines @@
 // when a task runs.
 TEST(TaskSchedulerTaskTrackerHistogramTest, TaskLatency) {
   auto statistics_recorder = StatisticsRecorder::CreateTemporaryForTesting();
 
   TaskTracker tracker;
 
   struct {
     const TaskTraits traits;
     const char* const expected_histogram;
   } tests[] = {
-      {TaskTraits().WithPriority(TaskPriority::BACKGROUND),
+      {{TaskPriority::BACKGROUND},
        "TaskScheduler.TaskLatencyMicroseconds.BackgroundTaskPriority"},
-      {TaskTraits().WithPriority(TaskPriority::BACKGROUND).MayBlock(),
+      {{MayBlock(), TaskPriority::BACKGROUND},
        "TaskScheduler.TaskLatencyMicroseconds.BackgroundTaskPriority.MayBlock"},
-      {TaskTraits()
-           .WithPriority(TaskPriority::BACKGROUND)
-           .WithBaseSyncPrimitives(),
+      {{WithBaseSyncPrimitives(), TaskPriority::BACKGROUND},
        "TaskScheduler.TaskLatencyMicroseconds.BackgroundTaskPriority.MayBlock"},
-      {TaskTraits().WithPriority(TaskPriority::USER_VISIBLE),
+      {{TaskPriority::USER_VISIBLE},
        "TaskScheduler.TaskLatencyMicroseconds.UserVisibleTaskPriority"},
-      {TaskTraits().WithPriority(TaskPriority::USER_VISIBLE).MayBlock(),
+      {{MayBlock(), TaskPriority::USER_VISIBLE},
        "TaskScheduler.TaskLatencyMicroseconds.UserVisibleTaskPriority."
        "MayBlock"},
-      {TaskTraits()
-           .WithPriority(TaskPriority::USER_VISIBLE)
-           .WithBaseSyncPrimitives(),
+      {{WithBaseSyncPrimitives(), TaskPriority::USER_VISIBLE},
        "TaskScheduler.TaskLatencyMicroseconds.UserVisibleTaskPriority."
        "MayBlock"},
-      {TaskTraits().WithPriority(TaskPriority::USER_BLOCKING),
+      {{TaskPriority::USER_BLOCKING},
        "TaskScheduler.TaskLatencyMicroseconds.UserBlockingTaskPriority"},
-      {TaskTraits().WithPriority(TaskPriority::USER_BLOCKING).MayBlock(),
+      {{MayBlock(), TaskPriority::USER_BLOCKING},
        "TaskScheduler.TaskLatencyMicroseconds.UserBlockingTaskPriority."
        "MayBlock"},
-      {TaskTraits()
-           .WithPriority(TaskPriority::USER_BLOCKING)
-           .WithBaseSyncPrimitives(),
+      {{WithBaseSyncPrimitives(), TaskPriority::USER_BLOCKING},
        "TaskScheduler.TaskLatencyMicroseconds.UserBlockingTaskPriority."
        "MayBlock"}};
 
   for (const auto& test : tests) {
     auto task =
         MakeUnique<Task>(FROM_HERE, Bind(&DoNothing), test.traits, TimeDelta());
     ASSERT_TRUE(tracker.WillPostTask(task.get()));
 
     HistogramTester tester;
     EXPECT_TRUE(tracker.RunTask(std::move(task), SequenceToken::Create()));
     tester.ExpectTotalCount(test.expected_histogram, 1);
   }
 }
 
 }  // namespace internal
 }  // namespace base