Do not inherit TaskPriority in TaskTraits.

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>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/histogram_samples.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/sequence_token.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/atomic_flag.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task_scheduler/scheduler_lock.h"
 #include "base/task_scheduler/task.h"
 #include "base/task_scheduler/task_traits.h"
+#include "base/task_scheduler/test_utils.h"
 #include "base/test/gtest_util.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/threading/simple_thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 102 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());
+        test::CreateTaskTraits().WithShutdownBehavior(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 107 matching lines @@
   WaitableEvent task_barrier(WaitableEvent::ResetPolicy::AUTOMATIC,
                              WaitableEvent::InitialState::NOT_SIGNALED);
   auto blocked_task = base::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()),
+      test::CreateTaskTraits().WithBaseSyncPrimitives().WithShutdownBehavior(
+          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();
@@ skipping 129 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()));
+  std::unique_ptr<Task> task(new Task(
+      FROM_HERE, BindOnce(&ThreadRestrictions::AssertSingletonAllowed),
+      test::CreateTaskTraits().WithShutdownBehavior(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());
+      test::CreateTaskTraits().MayBlock().WithShutdownBehavior(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());
+      test::CreateTaskTraits().WithShutdownBehavior(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 11 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()));
+  std::unique_ptr<Task> verify_task(new Task(
+      FROM_HERE, BindOnce(&VerifyNoTaskRunnerHandle),
+      test::CreateTaskTraits().WithShutdownBehavior(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()));
+  std::unique_ptr<Task> verify_task(new Task(
+      FROM_HERE,
+      BindOnce(&VerifySequencedTaskRunnerHandle,
+               base::Unretained(test_task_runner.get())),
+      test::CreateTaskTraits().WithShutdownBehavior(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()));
+  std::unique_ptr<Task> verify_task(new Task(
+      FROM_HERE,
+      BindOnce(&VerifyThreadTaskRunnerHandle,
+               base::Unretained(test_task_runner.get())),
+      test::CreateTaskTraits().WithShutdownBehavior(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));
+  Task delayed_task(FROM_HERE, BindOnce(&DoNothing),
+                    test::CreateTaskTraits().WithShutdownBehavior(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());
+      test::CreateTaskTraits().WithShutdownBehavior(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());
+      test::CreateTaskTraits().WithShutdownBehavior(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());
+      test::CreateTaskTraits().WithShutdownBehavior(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));
+      test::CreateTaskTraits().WithShutdownBehavior(GetParam()),
+      TimeDelta::FromDays(1));
   tracker_.WillPostTask(delayed_task.get());
   auto undelayed_task = base::MakeUnique<Task>(
       FROM_HERE, Bind(&DoNothing),
-      TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta());
+      test::CreateTaskTraits().WithShutdownBehavior(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());
+      test::CreateTaskTraits().WithShutdownBehavior(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());
+      test::CreateTaskTraits().WithShutdownBehavior(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 23 matching lines @@
 }
 
 }  // 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());
+                                     test::CreateTaskTraits(), 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 132 matching lines @@
   void Run() override {
     TaskTracker tracker;
 
     // Waiting is allowed by default. Expect TaskTracker to disallow it before
     // running a task without the WithBaseSyncPrimitives() trait.
     ThreadRestrictions::AssertWaitAllowed();
     auto task_without_sync_primitives = MakeUnique<Task>(
         FROM_HERE, Bind([]() {
           EXPECT_DCHECK_DEATH({ ThreadRestrictions::AssertWaitAllowed(); });
         }),
-        TaskTraits(), TimeDelta());
+        test::CreateTaskTraits(), TimeDelta());
     EXPECT_TRUE(tracker.WillPostTask(task_without_sync_primitives.get()));
     tracker.RunTask(std::move(task_without_sync_primitives),
                     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());
+    auto task_with_sync_primitives = MakeUnique<Task>(
+        FROM_HERE, Bind([]() {
+          // Shouldn't fail.
+          ThreadRestrictions::AssertWaitAllowed();
+        }),
+        test::CreateTaskTraits().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
 
 // Verify that AssertIOAllowed() succeeds only for a WithBaseSyncPrimitives()
 // task.
 TEST(TaskSchedulerTaskTrackerWaitAllowedTest, WaitAllowed) {
   // Run the test on the separate thread since it is not possible to reset the
   // "wait allowed" bit of a thread without being a friend of
   // ThreadRestrictions.
   WaitAllowedTestThread wait_allowed_test_thread;
   wait_allowed_test_thread.Start();
   wait_allowed_test_thread.Join();
 }
 
 // Verify that TaskScheduler.TaskLatency.* histograms are correctly recorded
 // when a task runs.
 TEST(TaskSchedulerTaskTrackerHistogramTest, TaskLatency) {
   auto statistics_recorder = StatisticsRecorder::CreateTemporaryForTesting();
 
   TaskTracker tracker;
 
   struct {
-    const TaskTraits traits;
+    TaskTraits traits;
     const char* const expected_histogram;
   } tests[] = {
-      {TaskTraits().WithPriority(TaskPriority::BACKGROUND),
+      {test::CreateTaskTraits().WithPriority(TaskPriority::BACKGROUND),
        "TaskScheduler.TaskLatency.BackgroundTaskPriority"},
-      {TaskTraits().WithPriority(TaskPriority::BACKGROUND).MayBlock(),
+      {test::CreateTaskTraits()
+           .WithPriority(TaskPriority::BACKGROUND)
+           .MayBlock(),
        "TaskScheduler.TaskLatency.BackgroundTaskPriority.MayBlock"},
-      {TaskTraits()
+      {test::CreateTaskTraits()
            .WithPriority(TaskPriority::BACKGROUND)
            .WithBaseSyncPrimitives(),
        "TaskScheduler.TaskLatency.BackgroundTaskPriority.MayBlock"},
-      {TaskTraits().WithPriority(TaskPriority::USER_VISIBLE),
+      {test::CreateTaskTraits().WithPriority(TaskPriority::USER_VISIBLE),
        "TaskScheduler.TaskLatency.UserVisibleTaskPriority"},
-      {TaskTraits().WithPriority(TaskPriority::USER_VISIBLE).MayBlock(),
+      {test::CreateTaskTraits()
+           .WithPriority(TaskPriority::USER_VISIBLE)
+           .MayBlock(),
        "TaskScheduler.TaskLatency.UserVisibleTaskPriority.MayBlock"},
-      {TaskTraits()
+      {test::CreateTaskTraits()
            .WithPriority(TaskPriority::USER_VISIBLE)
            .WithBaseSyncPrimitives(),
        "TaskScheduler.TaskLatency.UserVisibleTaskPriority.MayBlock"},
-      {TaskTraits().WithPriority(TaskPriority::USER_BLOCKING),
+      {test::CreateTaskTraits().WithPriority(TaskPriority::USER_BLOCKING),
        "TaskScheduler.TaskLatency.UserBlockingTaskPriority"},
-      {TaskTraits().WithPriority(TaskPriority::USER_BLOCKING).MayBlock(),
+      {test::CreateTaskTraits()
+           .WithPriority(TaskPriority::USER_BLOCKING)
+           .MayBlock(),
        "TaskScheduler.TaskLatency.UserBlockingTaskPriority.MayBlock"},
-      {TaskTraits()
+      {test::CreateTaskTraits()
            .WithPriority(TaskPriority::USER_BLOCKING)
            .WithBaseSyncPrimitives(),
        "TaskScheduler.TaskLatency.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