Add RetainedRef uses where needed.

base/threading/sequenced_worker_pool_unittest.cc

Index: base/threading/sequenced_worker_pool_unittest.cc
diff --git a/base/threading/sequenced_worker_pool_unittest.cc b/base/threading/sequenced_worker_pool_unittest.cc
index fba180843912216a31234657bc34dbdad2f78f98..d3cce32816c84388d88212a165a6a87403d11a9c 100644
--- a/base/threading/sequenced_worker_pool_unittest.cc
+++ b/base/threading/sequenced_worker_pool_unittest.cc
@@ -567,9 +567,8 @@ TEST_F(SequencedWorkerPoolTest, AllowsAfterShutdown) {
   const int kNumQueuedTasks = static_cast<int>(kNumWorkerThreads);
   for (int i = 0; i < kNumQueuedTasks; ++i) {
     EXPECT_TRUE(pool()->PostWorkerTaskWithShutdownBehavior(
-        FROM_HERE,
-        base::Bind(&TestTracker::PostAdditionalTasks, tracker(), i, pool(),
-                   false),
+        FROM_HERE, base::Bind(&TestTracker::PostAdditionalTasks, tracker(), i,
+                              base::RetainedRef(pool()), false),
         SequencedWorkerPool::BLOCK_SHUTDOWN));
   }
 
@@ -809,15 +808,19 @@ TEST_F(SequencedWorkerPoolTest, IsRunningOnCurrentThread) {
       unsequenced_token));
 
   pool()->PostSequencedWorkerTask(
-      token1, FROM_HERE, base::Bind(&IsRunningOnCurrentThreadTask, token1,
-                                    token2, pool(), unused_pool_owner.pool()));
+      token1, FROM_HERE,
+      base::Bind(&IsRunningOnCurrentThreadTask, token1, token2,
+                 base::RetainedRef(pool()),
+                 base::RetainedRef(unused_pool_owner.pool())));
   pool()->PostSequencedWorkerTask(
       token2, FROM_HERE,
       base::Bind(&IsRunningOnCurrentThreadTask, token2, unsequenced_token,
-                 pool(), unused_pool_owner.pool()));
+                 base::RetainedRef(pool()),
+                 base::RetainedRef(unused_pool_owner.pool())));
   pool()->PostWorkerTask(
       FROM_HERE, base::Bind(&IsRunningOnCurrentThreadTask, unsequenced_token,
-                            token1, pool(), unused_pool_owner.pool()));
+                            token1, base::RetainedRef(pool()),
+                            base::RetainedRef(unused_pool_owner.pool())));
 }
 
 // Checks that tasks are destroyed in the right context during shutdown. If a
@@ -874,9 +877,8 @@ TEST_F(SequencedWorkerPoolTest, FlushForTesting) {
                            base::Bind(&TestTracker::FastTask, tracker(), 0));
   }
   pool()->PostWorkerTask(
-      FROM_HERE,
-      base::Bind(&TestTracker::PostAdditionalTasks, tracker(), 0, pool(),
-                 true));
+      FROM_HERE, base::Bind(&TestTracker::PostAdditionalTasks, tracker(), 0,
+                            base::RetainedRef(pool()), true));
 
   // We expect all except the delayed task to have been run. We verify all
   // closures have been deleted by looking at the refcount of the
@@ -950,10 +952,10 @@ void VerifyCurrentSequencedTaskRunnerForUnsequencedTask(
   // VerifyCurrentSequencedTaskRunner() above for why the check is implemented
   // this way.
   const bool expected_equal = true;
-  task_runner->PostTask(
-      FROM_HERE,
-      Bind(&VerifySequencedTaskRunnerRunsOnCurrentThread,
-           std::move(expected_task_runner), expected_equal, callback));
+  task_runner->PostTask(FROM_HERE,
+                        Bind(&VerifySequencedTaskRunnerRunsOnCurrentThread,
+                             RetainedRef(std::move(expected_task_runner)),
+                             expected_equal, callback));
 }
 
 TEST_F(SequencedWorkerPoolTest, GetSequencedTaskRunnerForCurrentThread) {
@@ -987,7 +989,7 @@ TEST_F(SequencedWorkerPoolTest, GetSequencedTaskRunnerForCurrentThread) {
 
   pool()->PostWorkerTask(
       FROM_HERE, Bind(&VerifyCurrentSequencedTaskRunnerForUnsequencedTask,
-                      pool(), signal));
+                      RetainedRef(pool()), signal));
   event.Wait();
 }