Add RetainedRef uses where needed.

base/threading/sequenced_worker_pool_unittest.cc

 // Copyright (c) 2012 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/threading/sequenced_worker_pool.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 548 matching lines @@
         base::Bind(&TestTracker::BlockTask, tracker(), i, &blocker)));
   }
   tracker()->WaitUntilTasksBlocked(kNumWorkerThreads);
 
   // Queue up shutdown blocking tasks behind those which will attempt to post
   // additional tasks when run, PostAdditionalTasks attemtps to post 3
   // new FastTasks, one for each shutdown_behavior.
   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));
   }
 
   // Setup to open the floodgates from within Shutdown().
   SetWillWaitForShutdownCallback(
       base::Bind(&EnsureTasksToCompleteCountAndUnblock,
                  scoped_refptr<TestTracker>(tracker()),
                  0, &blocker, kNumBlockTasks));
 
   // Allow half of the additional blocking tasks thru.
@@ skipping 219 matching lines @@
   EXPECT_FALSE(pool()->IsRunningSequenceOnCurrentThread(unsequenced_token));
   EXPECT_FALSE(unused_pool_owner.pool()->RunsTasksOnCurrentThread());
   EXPECT_FALSE(
       unused_pool_owner.pool()->IsRunningSequenceOnCurrentThread(token1));
   EXPECT_FALSE(
       unused_pool_owner.pool()->IsRunningSequenceOnCurrentThread(token2));
   EXPECT_FALSE(unused_pool_owner.pool()->IsRunningSequenceOnCurrentThread(
       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
 // task is destroyed while SequencedWorkerPool's global lock is held,
 // SequencedWorkerPool might deadlock.
 TEST_F(SequencedWorkerPoolTest, AvoidsDeadlockOnShutdown) {
   for (int i = 0; i < 4; ++i) {
     scoped_refptr<DestructionDeadlockChecker> checker(
         new DestructionDeadlockChecker(pool()));
     tracker()->PostRepostingTask(pool(), checker);
@@ skipping 36 matching lines @@
       base::Bind(&TestTracker::FastTask, tracker(), 0),
       TimeDelta::FromMinutes(5));
   pool()->PostWorkerTask(FROM_HERE,
                          base::Bind(&TestTracker::SlowTask, tracker(), 0));
   const size_t kNumFastTasks = 20;
   for (size_t i = 0; i < kNumFastTasks; i++) {
     pool()->PostWorkerTask(FROM_HERE,
                            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
   // tracker.
   EXPECT_FALSE(tracker()->HasOneRef());
   pool()->FlushForTesting();
   EXPECT_TRUE(tracker()->HasOneRef());
   EXPECT_EQ(1 + kNumFastTasks + 1 + 3, tracker()->GetTasksCompletedCount());
 
   // Should be fine to call on an idle instance with all threads created, and
@@ skipping 53 matching lines @@
   // thread will start running tasks with this sequence token.
   const SequencedWorkerPool::SequenceToken sequence_token =
       SequencedWorkerPool::GetSequenceTokenForCurrentThread();
   ASSERT_TRUE(sequence_token.IsValid());
   EXPECT_TRUE(pool->IsRunningSequence(sequence_token));
 
   // The two sequenced task runners should be the same. See
   // 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) {
   EnsureAllWorkersCreated();
 
   // The current thread should not have a sequenced task runner from a
   // worker pool.
   scoped_refptr<SequencedTaskRunner> local_task_runner =
       SequencedWorkerPool::GetSequencedTaskRunnerForCurrentThread();
   EXPECT_FALSE(local_task_runner);
@@ skipping 13 matching lines @@
                       base::Unretained(task_runner_2.get()), true, signal));
   event.Wait();
 
   task_runner_1->PostTask(
       FROM_HERE, Bind(&VerifyCurrentSequencedTaskRunner,
                       base::Unretained(task_runner_2.get()), false, signal));
   event.Wait();
 
   pool()->PostWorkerTask(
       FROM_HERE, Bind(&VerifyCurrentSequencedTaskRunnerForUnsequencedTask,
-                      pool(), signal));
+                      RetainedRef(pool()), signal));
   event.Wait();
 }
 
 class ChecksSequenceOnDestruction
     : public RefCountedThreadSafe<ChecksSequenceOnDestruction> {
  public:
   void DoNothing() {}
 
  private:
   friend class RefCountedThreadSafe<ChecksSequenceOnDestruction>;
@@ skipping 158 matching lines @@
     SequencedWorkerPoolSequencedTaskRunner, SequencedTaskRunnerTest,
     SequencedWorkerPoolSequencedTaskRunnerTestDelegate);
 INSTANTIATE_TYPED_TEST_CASE_P(
     SequencedWorkerPoolSequencedTaskRunner,
     SequencedTaskRunnerDelayedTest,
     SequencedWorkerPoolSequencedTaskRunnerTestDelegate);
 
 }  // namespace
 
 }  // namespace base