Add RetainedRef uses where needed.

This patch adds RetainedRef uses where they are required. These
changes will be required when we remove automatic unwrapping of
scoped_refptrs in Bind.

Please see the bug for more context.

R=tzik@chromium.org, thakis@chromium.org, danakj@chromium.org
BUG=589048

Review URL: https://codereview.chromium.org/1815363002

Cr-Commit-Position: refs/heads/master@{#382371}

7 files changed, 39 insertions, 32 deletions

diff --git a/base/deferred_sequenced_task_runner_unittest.cc b/base/deferred_sequenced_task_runner_unittest.cc
index 883a3dd..1ddc354 100644
--- a/base/deferred_sequenced_task_runner_unittest.cc
+++ b/base/deferred_sequenced_task_runner_unittest.cc
@@ -156,10 +156,9 @@ TEST_F(DeferredSequencedTaskRunnerTest, ObjectDestructionOrder) {
         scoped_refptr<ExecuteTaskOnDestructor> short_lived_object =
             new ExecuteTaskOnDestructor(this, 2 * i);
         runner_->PostTask(
-            FROM_HERE,
-            base::Bind(&DeferredSequencedTaskRunnerTest::DoNothing,
-                       base::Unretained(this),
-                       short_lived_object));
+            FROM_HERE, base::Bind(&DeferredSequencedTaskRunnerTest::DoNothing,
+                                  base::Unretained(this),
+                                  base::RetainedRef(short_lived_object)));
       }
       // |short_lived_object| with id |2 * i| should be destroyed before the
       // task |2 * i + 1| is executed.
diff --git a/base/synchronization/waitable_event_watcher_posix.cc b/base/synchronization/waitable_event_watcher_posix.cc
index aa425f2..7cf8688 100644
--- a/base/synchronization/waitable_event_watcher_posix.cc
+++ b/base/synchronization/waitable_event_watcher_posix.cc
@@ -145,8 +145,8 @@ bool WaitableEventWatcher::StartWatching(
 
   cancel_flag_ = new Flag;
   callback_ = callback;
-  internal_callback_ =
-      base::Bind(&AsyncCallbackHelper, cancel_flag_, callback_, event);
+  internal_callback_ = base::Bind(
+      &AsyncCallbackHelper, base::RetainedRef(cancel_flag_), callback_, event);
   WaitableEvent::WaitableEventKernel* kernel = event->kernel_.get();
 
   AutoLock locked(kernel->lock_);
diff --git a/base/task/cancelable_task_tracker.cc b/base/task/cancelable_task_tracker.cc
index a756f4e..881249b 100644
--- a/base/task/cancelable_task_tracker.cc
+++ b/base/task/cancelable_task_tracker.cc
@@ -131,9 +131,10 @@ CancelableTaskTracker::TaskId CancelableTaskTracker::NewTrackedTaskId(
 
   // Will always run |untrack_and_delete_flag| on current MessageLoop.
   base::ScopedClosureRunner* untrack_and_delete_flag_runner =
-      new base::ScopedClosureRunner(Bind(&RunOrPostToTaskRunner,
-                                         base::ThreadTaskRunnerHandle::Get(),
-                                         untrack_and_delete_flag));
+      new base::ScopedClosureRunner(
+          Bind(&RunOrPostToTaskRunner,
+               RetainedRef(base::ThreadTaskRunnerHandle::Get()),
+               untrack_and_delete_flag));
 
   *is_canceled_cb =
       Bind(&IsCanceled, flag, base::Owned(untrack_and_delete_flag_runner));
diff --git a/base/test/launcher/test_launcher.cc b/base/test/launcher/test_launcher.cc
index 6550790..65471c7 100644
--- a/base/test/launcher/test_launcher.cc
+++ b/base/test/launcher/test_launcher.cc
@@ -563,11 +563,12 @@ void TestLauncher::LaunchChildGTestProcess(
   bool redirect_stdio = (parallel_jobs_ > 1) || BotModeEnabled();
 
   worker_pool_owner_->pool()->PostWorkerTask(
-      FROM_HERE, Bind(&DoLaunchChildTestProcess, new_command_line, timeout,
-                      options, redirect_stdio, ThreadTaskRunnerHandle::Get(),
-                      Bind(&TestLauncher::OnLaunchTestProcessFinished,
-                           Unretained(this), completed_callback),
-                      launched_callback));
+      FROM_HERE,
+      Bind(&DoLaunchChildTestProcess, new_command_line, timeout, options,
+           redirect_stdio, RetainedRef(ThreadTaskRunnerHandle::Get()),
+           Bind(&TestLauncher::OnLaunchTestProcessFinished, Unretained(this),
+                completed_callback),
+           launched_callback));
 }
 
 void TestLauncher::OnTestFinished(const TestResult& result) {
diff --git a/base/test/sequenced_task_runner_test_template.h b/base/test/sequenced_task_runner_test_template.h
index ac5f3c6..a510030 100644
--- a/base/test/sequenced_task_runner_test_template.h
+++ b/base/test/sequenced_task_runner_test_template.h
@@ -211,7 +211,7 @@ TYPED_TEST_P(SequencedTaskRunnerTest, NonNestablePostFromNonNestableTask) {
     Closure task = Bind(
         &internal::SequencedTaskTracker::PostNonNestableTasks,
         this->task_tracker_,
-        task_runner,
+        RetainedRef(task_runner),
         kChildrenPerParent);
     this->task_tracker_->PostWrappedNonNestableTask(task_runner.get(), task);
   }
diff --git a/base/test/task_runner_test_template.h b/base/test/task_runner_test_template.h
index c0d3a12..ed04865 100644
--- a/base/test/task_runner_test_template.h
+++ b/base/test/task_runner_test_template.h
@@ -201,9 +201,13 @@ TYPED_TEST_P(TaskRunnerAffinityTest, RunsTasksOnCurrentThread) {
   // the non-task-runner thread.
   for (int i = 0; i < 20; ++i) {
     const Closure& ith_task_runner_task = this->task_tracker_->WrapTask(
-        Bind(&test::ExpectRunsTasksOnCurrentThread, true, task_runner), i);
+        Bind(&test::ExpectRunsTasksOnCurrentThread, true,
+             base::RetainedRef(task_runner)),
+        i);
     const Closure& ith_non_task_runner_task = this->task_tracker_->WrapTask(
-        Bind(&test::ExpectRunsTasksOnCurrentThread, false, task_runner), i);
+        Bind(&test::ExpectRunsTasksOnCurrentThread, false,
+             base::RetainedRef(task_runner)),
+        i);
     for (int j = 0; j < i + 1; ++j) {
       task_runner->PostTask(FROM_HERE, ith_task_runner_task);
       thread.task_runner()->PostTask(FROM_HERE, ith_non_task_runner_task);
diff --git a/base/threading/sequenced_worker_pool_unittest.cc b/base/threading/sequenced_worker_pool_unittest.cc
index 2855b9f..a0be607 100644
--- a/base/threading/sequenced_worker_pool_unittest.cc
+++ b/base/threading/sequenced_worker_pool_unittest.cc
@@ -566,9 +566,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));
   }
 
@@ -808,15 +807,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
@@ -873,9 +876,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
@@ -949,10 +951,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) {
@@ -986,7 +988,7 @@ TEST_F(SequencedWorkerPoolTest, GetSequencedTaskRunnerForCurrentThread) {
 
   pool()->PostWorkerTask(
       FROM_HERE, Bind(&VerifyCurrentSequencedTaskRunnerForUnsequencedTask,
-                      pool(), signal));
+                      RetainedRef(pool()), signal));
   event.Wait();
 }