TaskScheduler: Change Sequence::PeekTask to Sequence::TakeTask.

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/sequence_token.h"
 #include "base/sequenced_task_runner.h"
@@ skipping 50 matching lines @@
   };
 
   ThreadPostingAndRunningTask(TaskTracker* tracker,
                               Task* task,
                               Action action,
                               bool expect_post_succeeds)
       : SimpleThread("ThreadPostingAndRunningTask"),
         tracker_(tracker),
         task_(task),
         action_(action),
-        expect_post_succeeds_(expect_post_succeeds) {}
+        expect_post_succeeds_(expect_post_succeeds) {
+    EXPECT_TRUE(task_);
+
+    // Ownership of the Task is required to run it.
+    EXPECT_NE(Action::RUN, action_);
+    EXPECT_NE(Action::WILL_POST_AND_RUN, action_);
+  }
+
+  ThreadPostingAndRunningTask(TaskTracker* tracker,
+                              std::unique_ptr<Task> task,
+                              Action action,
+                              bool expect_post_succeeds)
+      : SimpleThread("ThreadPostingAndRunningTask"),
+        tracker_(tracker),
+        task_(task.get()),
+        owned_task_(std::move(task)),
+        action_(action),
+        expect_post_succeeds_(expect_post_succeeds) {
+    EXPECT_TRUE(task_);
+  }
 
  private:
   void Run() override {
     bool post_succeeded = true;
     if (action_ == Action::WILL_POST || action_ == Action::WILL_POST_AND_RUN) {
       post_succeeded = tracker_->WillPostTask(task_);
       EXPECT_EQ(expect_post_succeeds_, post_succeeded);
     }
     if (post_succeeded &&
         (action_ == Action::RUN || action_ == Action::WILL_POST_AND_RUN)) {
-      tracker_->RunTask(task_, SequenceToken::Create());
+      EXPECT_TRUE(owned_task_);
+      tracker_->RunTask(std::move(owned_task_), SequenceToken::Create());
     }
   }
 
   TaskTracker* const tracker_;
   Task* const task_;
+  std::unique_ptr<Task> owned_task_;
   const Action action_;
   const bool expect_post_succeeds_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadPostingAndRunningTask);
 };
 
 class ScopedSetSingletonAllowed {
  public:
   ScopedSetSingletonAllowed(bool singleton_allowed)
       : previous_value_(
@@ skipping 115 matching lines @@
 }  // namespace
 
 TEST_P(TaskSchedulerTaskTrackerTest, WillPostAndRunBeforeShutdown) {
   std::unique_ptr<Task> task(CreateTask(GetParam()));
 
   // Inform |task_tracker_| that |task| will be posted.
   EXPECT_TRUE(tracker_.WillPostTask(task.get()));
 
   // Run the task.
   EXPECT_EQ(0U, NumTasksExecuted());
-  EXPECT_TRUE(tracker_.RunTask(task.get(), SequenceToken::Create()));
+  EXPECT_TRUE(tracker_.RunTask(std::move(task), SequenceToken::Create()));
   EXPECT_EQ(1U, NumTasksExecuted());
 
   // Shutdown() shouldn't block.
   tracker_.Shutdown();
 }
 
 TEST_P(TaskSchedulerTaskTrackerTest, WillPostAndRunLongTaskBeforeShutdown) {
   // Create a task that will block until |event| is signaled.
   WaitableEvent event(WaitableEvent::ResetPolicy::AUTOMATIC,
                       WaitableEvent::InitialState::NOT_SIGNALED);
-  Task blocked_task(FROM_HERE, Bind(&WaitableEvent::Wait, Unretained(&event)),
-                    TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta());
+  auto blocked_task = base::MakeUnique<Task>(
+      FROM_HERE, Bind(&WaitableEvent::Wait, Unretained(&event)),
+      TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta());
 
   // Inform |task_tracker_| that |blocked_task| will be posted.
-  EXPECT_TRUE(tracker_.WillPostTask(&blocked_task));
+  EXPECT_TRUE(tracker_.WillPostTask(blocked_task.get()));
 
   // Run the task asynchronouly.
   ThreadPostingAndRunningTask thread_running_task(
-      &tracker_, &blocked_task, ThreadPostingAndRunningTask::Action::RUN,
-      false);
+      &tracker_, std::move(blocked_task),
+      ThreadPostingAndRunningTask::Action::RUN, false);
   thread_running_task.Start();
 
   // Initiate shutdown while the task is running.
   CallShutdownAsync();
 
   if (GetParam() == TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN) {
     // Shutdown should complete even with a CONTINUE_ON_SHUTDOWN in progress.
     WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
   } else {
     // Shutdown should block with any non CONTINUE_ON_SHUTDOWN task in progress.
@@ skipping 21 matching lines @@
   EXPECT_TRUE(tracker_.WillPostTask(block_shutdown_task.get()));
 
   // Call Shutdown() asynchronously.
   CallShutdownAsync();
   VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS();
 
   // Try to run |task|. It should only run it it's BLOCK_SHUTDOWN. Otherwise it
   // should be discarded.
   EXPECT_EQ(0U, NumTasksExecuted());
   const bool should_run = GetParam() == TaskShutdownBehavior::BLOCK_SHUTDOWN;
-  EXPECT_EQ(should_run, tracker_.RunTask(task.get(), SequenceToken::Create()));
+  EXPECT_EQ(should_run,
+            tracker_.RunTask(std::move(task), SequenceToken::Create()));
   EXPECT_EQ(should_run ? 1U : 0U, NumTasksExecuted());
   VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS();
 
   // Unblock shutdown by running the remaining BLOCK_SHUTDOWN task.
-  EXPECT_TRUE(
-      tracker_.RunTask(block_shutdown_task.get(), SequenceToken::Create()));
+  EXPECT_TRUE(tracker_.RunTask(std::move(block_shutdown_task),
+                               SequenceToken::Create()));
   EXPECT_EQ(should_run ? 2U : 1U, NumTasksExecuted());
   WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
 }
 
 TEST_P(TaskSchedulerTaskTrackerTest, WillPostBeforeShutdownRunAfterShutdown) {
   // Inform |task_tracker_| that a task will be posted.
   std::unique_ptr<Task> task(CreateTask(GetParam()));
   EXPECT_TRUE(tracker_.WillPostTask(task.get()));
 
   // Call Shutdown() asynchronously.
   CallShutdownAsync();
   EXPECT_EQ(0U, NumTasksExecuted());
 
   if (GetParam() == TaskShutdownBehavior::BLOCK_SHUTDOWN) {
     VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS();
 
     // Run the task to unblock shutdown.
-    EXPECT_TRUE(tracker_.RunTask(task.get(), SequenceToken::Create()));
+    EXPECT_TRUE(tracker_.RunTask(std::move(task), SequenceToken::Create()));
     EXPECT_EQ(1U, NumTasksExecuted());
     WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
 
     // It is not possible to test running a BLOCK_SHUTDOWN task posted before
     // shutdown after shutdown because Shutdown() won't return if there are
     // pending BLOCK_SHUTDOWN tasks.
   } else {
     WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
 
     // The task shouldn't be allowed to run after shutdown.
-    EXPECT_FALSE(tracker_.RunTask(task.get(), SequenceToken::Create()));
+    EXPECT_FALSE(tracker_.RunTask(std::move(task), SequenceToken::Create()));
     EXPECT_EQ(0U, NumTasksExecuted());
   }
 }
 
 TEST_P(TaskSchedulerTaskTrackerTest, WillPostAndRunDuringShutdown) {
   // Inform |task_tracker_| that a BLOCK_SHUTDOWN task will be posted just to
   // block shutdown.
   std::unique_ptr<Task> block_shutdown_task(
       CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN));
   EXPECT_TRUE(tracker_.WillPostTask(block_shutdown_task.get()));
 
   // Call Shutdown() asynchronously.
   CallShutdownAsync();
   VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS();
 
   if (GetParam() == TaskShutdownBehavior::BLOCK_SHUTDOWN) {
     // Inform |task_tracker_| that a BLOCK_SHUTDOWN task will be posted.
     std::unique_ptr<Task> task(CreateTask(GetParam()));
     EXPECT_TRUE(tracker_.WillPostTask(task.get()));
 
     // Run the BLOCK_SHUTDOWN task.
     EXPECT_EQ(0U, NumTasksExecuted());
-    EXPECT_TRUE(tracker_.RunTask(task.get(), SequenceToken::Create()));
+    EXPECT_TRUE(tracker_.RunTask(std::move(task), SequenceToken::Create()));
     EXPECT_EQ(1U, NumTasksExecuted());
   } else {
     // It shouldn't be allowed to post a non BLOCK_SHUTDOWN task.
     std::unique_ptr<Task> task(CreateTask(GetParam()));
     EXPECT_FALSE(tracker_.WillPostTask(task.get()));
 
     // Don't try to run the task, because it wasn't allowed to be posted.
   }
 
   // Unblock shutdown by running |block_shutdown_task|.
   VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS();
-  EXPECT_TRUE(
-      tracker_.RunTask(block_shutdown_task.get(), SequenceToken::Create()));
+  EXPECT_TRUE(tracker_.RunTask(std::move(block_shutdown_task),
+                               SequenceToken::Create()));
   EXPECT_EQ(GetParam() == TaskShutdownBehavior::BLOCK_SHUTDOWN ? 2U : 1U,
             NumTasksExecuted());
   WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
 }
 
 TEST_P(TaskSchedulerTaskTrackerTest, WillPostAfterShutdown) {
   tracker_.Shutdown();
 
   std::unique_ptr<Task> task(CreateTask(GetParam()));
 
@@ skipping 17 matching lines @@
                TaskTraits().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(task.get(), SequenceToken::Create()));
+    EXPECT_TRUE(tracker.RunTask(std::move(task), SequenceToken::Create()));
   } else {
     EXPECT_DCHECK_DEATH(
-        { tracker.RunTask(task.get(), SequenceToken::Create()); });
+        { tracker.RunTask(std::move(task), 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()));
 
   // Confirm that the test conditions are right (no TaskRunnerHandles set
   // already).
   EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
   EXPECT_FALSE(SequencedTaskRunnerHandle::IsSet());
 
-  EXPECT_TRUE(tracker->RunTask(verify_task.get(), SequenceToken::Create()));
+  EXPECT_TRUE(
+      tracker->RunTask(std::move(verify_task), SequenceToken::Create()));
 
   // TaskRunnerHandle state is reset outside of task's scope.
   EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
   EXPECT_FALSE(SequencedTaskRunnerHandle::IsSet());
 }
 
 static void VerifyNoTaskRunnerHandle() {
   EXPECT_FALSE(ThreadTaskRunnerHandle::IsSet());
   EXPECT_FALSE(SequencedTaskRunnerHandle::IsSet());
 }
@@ skipping 59 matching lines @@
 TEST_P(TaskSchedulerTaskTrackerTest, FlushPendingDelayedTask) {
   const Task delayed_task(FROM_HERE, Bind(&DoNothing),
                           TaskTraits().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) {
-  const Task undelayed_task(FROM_HERE, Bind(&DoNothing),
-                            TaskTraits().WithShutdownBehavior(GetParam()),
-                            TimeDelta());
-  tracker_.WillPostTask(&undelayed_task);
+  auto undelayed_task = base::MakeUnique<Task>(
+      FROM_HERE, Bind(&DoNothing),
+      TaskTraits().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(&undelayed_task, SequenceToken::Create());
+  tracker_.RunTask(std::move(undelayed_task), SequenceToken::Create());
   WAIT_FOR_ASYNC_FLUSH_RETURNED();
 }
 
 TEST_P(TaskSchedulerTaskTrackerTest, PostTaskDuringFlush) {
-  const Task undelayed_task(FROM_HERE, Bind(&DoNothing),
-                            TaskTraits().WithShutdownBehavior(GetParam()),
-                            TimeDelta());
-  tracker_.WillPostTask(&undelayed_task);
+  auto undelayed_task = base::MakeUnique<Task>(
+      FROM_HERE, Bind(&DoNothing),
+      TaskTraits().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.
-  const Task other_undelayed_task(FROM_HERE, Bind(&DoNothing),
-                                  TaskTraits().WithShutdownBehavior(GetParam()),
-                                  TimeDelta());
-  tracker_.WillPostTask(&other_undelayed_task);
+  auto other_undelayed_task = base::MakeUnique<Task>(
+      FROM_HERE, Bind(&DoNothing),
+      TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta());
+  tracker_.WillPostTask(other_undelayed_task.get());
 
   // Run the first undelayed task.
-  tracker_.RunTask(&undelayed_task, SequenceToken::Create());
+  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(&other_undelayed_task, SequenceToken::Create());
+  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.
-  const Task delayed_task(FROM_HERE, Bind(&DoNothing),
-                          TaskTraits().WithShutdownBehavior(GetParam()),
-                          TimeDelta::FromDays(1));
-  tracker_.WillPostTask(&delayed_task);
-  const Task undelayed_task(FROM_HERE, Bind(&DoNothing),
-                            TaskTraits().WithShutdownBehavior(GetParam()),
-                            TimeDelta());
-  tracker_.WillPostTask(&undelayed_task);
+  auto delayed_task = base::MakeUnique<Task>(
+      FROM_HERE, Bind(&DoNothing),
+      TaskTraits().WithShutdownBehavior(GetParam()), TimeDelta::FromDays(1));
+  tracker_.WillPostTask(delayed_task.get());
+  auto undelayed_task = base::MakeUnique<Task>(
+      FROM_HERE, Bind(&DoNothing),
+      TaskTraits().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(&delayed_task, SequenceToken::Create());
+  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(&undelayed_task, SequenceToken::Create());
+  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.
-  const Task undelayed_task(FROM_HERE, Bind(&DoNothing),
-                            TaskTraits().WithShutdownBehavior(GetParam()),
-                            TimeDelta());
-  tracker_.WillPostTask(&undelayed_task);
+  auto undelayed_task = base::MakeUnique<Task>(
+      FROM_HERE, Bind(&DoNothing),
+      TaskTraits().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.
-  const Task undelayed_task(FROM_HERE, Bind(&DoNothing),
-                            TaskTraits().WithShutdownBehavior(GetParam()),
-                            TimeDelta());
-  tracker_.WillPostTask(&undelayed_task);
+  auto undelayed_task = base::MakeUnique<Task>(
+      FROM_HERE, Bind(&DoNothing),
+      TaskTraits().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.
   tracker_.Shutdown();
@@ skipping 20 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());
-  Task task(FROM_HERE, Bind(&ExpectSequenceToken, sequence_token), TaskTraits(),
-            TimeDelta());
-  tracker_.WillPostTask(&task);
+  auto task = base::MakeUnique<Task>(FROM_HERE,
+                                     Bind(&ExpectSequenceToken, sequence_token),
+                                     TaskTraits(), TimeDelta());
+  tracker_.WillPostTask(task.get());
 
   EXPECT_FALSE(SequenceToken::GetForCurrentThread().IsValid());
-  EXPECT_TRUE(tracker_.RunTask(&task, sequence_token));
+  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<Task>> tasks;
   std::vector<std::unique_ptr<ThreadPostingAndRunningTask>> threads;
 
   for (size_t i = 0; i < kLoadTestNumIterations; ++i) {
-    tasks.push_back(CreateTask(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN));
     threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(
-        &tracker_, tasks.back().get(),
+        &tracker_, CreateTask(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),
         ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, true));
     threads.back()->Start();
 
-    tasks.push_back(CreateTask(TaskShutdownBehavior::SKIP_ON_SHUTDOWN));
     threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(
-        &tracker_, tasks.back().get(),
+        &tracker_, CreateTask(TaskShutdownBehavior::SKIP_ON_SHUTDOWN),
         ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, true));
     threads.back()->Start();
 
-    tasks.push_back(CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN));
     threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(
-        &tracker_, tasks.back().get(),
+        &tracker_, CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN),
         ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, true));
     threads.back()->Start();
   }
 
   for (const auto& thread : threads)
     thread->Join();
 
   // Expect all tasks to be executed.
   EXPECT_EQ(kLoadTestNumIterations * 3, NumTasksExecuted());
 
@@ skipping 29 matching lines @@
 
   for (const auto& thread : post_threads)
     thread->Join();
 
   // Call Shutdown() asynchronously.
   CallShutdownAsync();
 
   // Run tasks asynchronously.
   std::vector<std::unique_ptr<ThreadPostingAndRunningTask>> run_threads;
 
-  for (const auto& task : tasks) {
+  for (auto& task : tasks) {
     run_threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(
-        &tracker_, task.get(), ThreadPostingAndRunningTask::Action::RUN,
+        &tracker_, std::move(task), ThreadPostingAndRunningTask::Action::RUN,
         false));
     run_threads.back()->Start();
   }
 
   for (const auto& thread : run_threads)
     thread->Join();
 
   WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
 
   // Expect BLOCK_SHUTDOWN tasks to have been executed.
   EXPECT_EQ(kLoadTestNumIterations, NumTasksExecuted());
 }
 
 TEST_F(TaskSchedulerTaskTrackerTest, LoadWillPostAndRunDuringShutdown) {
   // Inform |task_tracker_| that a BLOCK_SHUTDOWN task will be posted just to
   // block shutdown.
   std::unique_ptr<Task> block_shutdown_task(
       CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN));
   EXPECT_TRUE(tracker_.WillPostTask(block_shutdown_task.get()));
 
   // Call Shutdown() asynchronously.
   CallShutdownAsync();
 
   // Post and run tasks asynchronously.
-  std::vector<std::unique_ptr<Task>> tasks;
   std::vector<std::unique_ptr<ThreadPostingAndRunningTask>> threads;
 
   for (size_t i = 0; i < kLoadTestNumIterations; ++i) {
-    tasks.push_back(CreateTask(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN));
     threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(
-        &tracker_, tasks.back().get(),
+        &tracker_, CreateTask(TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),
         ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, false));
     threads.back()->Start();
 
-    tasks.push_back(CreateTask(TaskShutdownBehavior::SKIP_ON_SHUTDOWN));
     threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(
-        &tracker_, tasks.back().get(),
+        &tracker_, CreateTask(TaskShutdownBehavior::SKIP_ON_SHUTDOWN),
         ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, false));
     threads.back()->Start();
 
-    tasks.push_back(CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN));
     threads.push_back(MakeUnique<ThreadPostingAndRunningTask>(
-        &tracker_, tasks.back().get(),
+        &tracker_, CreateTask(TaskShutdownBehavior::BLOCK_SHUTDOWN),
         ThreadPostingAndRunningTask::Action::WILL_POST_AND_RUN, true));
     threads.back()->Start();
   }
 
   for (const auto& thread : threads)
     thread->Join();
 
   // Expect BLOCK_SHUTDOWN tasks to have been executed.
   EXPECT_EQ(kLoadTestNumIterations, NumTasksExecuted());
 
   // Shutdown() shouldn't return before |block_shutdown_task| is executed.
   VERIFY_ASYNC_SHUTDOWN_IN_PROGRESS();
 
   // Unblock shutdown by running |block_shutdown_task|.
-  EXPECT_TRUE(
-      tracker_.RunTask(block_shutdown_task.get(), SequenceToken::Create()));
+  EXPECT_TRUE(tracker_.RunTask(std::move(block_shutdown_task),
+                               SequenceToken::Create()));
   EXPECT_EQ(kLoadTestNumIterations + 1, NumTasksExecuted());
   WAIT_FOR_ASYNC_SHUTDOWN_COMPLETED();
 }
 
 }  // namespace internal
 }  // namespace base