Add RetainedRef uses where needed.

components/scheduler/base/task_queue_manager_unittest.cc

 // Copyright 2014 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 "components/scheduler/base/task_queue_manager.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/location.h"
@@ skipping 191 matching lines @@
 
   std::vector<std::pair<base::Closure, bool>> tasks_to_post_from_nested_loop;
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&TestTask, 3, &run_order), false));
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&TestTask, 4, &run_order), true));
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&TestTask, 5, &run_order), true));
 
   runners_[0]->PostTask(
-      FROM_HERE,
-      base::Bind(&PostFromNestedRunloop, message_loop_.get(), runners_[0],
-                 base::Unretained(&tasks_to_post_from_nested_loop)));
+      FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(),
+                            base::RetainedRef(runners_[0]),
+                            base::Unretained(&tasks_to_post_from_nested_loop)));
 
   message_loop_->RunUntilIdle();
   // Note we expect task 3 to run last because it's non-nestable.
   EXPECT_THAT(run_order, ElementsAre(1, 2, 4, 5, 3));
 }
 
 TEST_F(TaskQueueManagerTest, QueuePolling) {
   Initialize(1u);
 
   std::vector<EnqueueOrder> run_order;
@@ skipping 385 matching lines @@
 TEST_F(TaskQueueManagerTest, PostFromNestedRunloop) {
   InitializeWithRealMessageLoop(1u);
 
   std::vector<EnqueueOrder> run_order;
   std::vector<std::pair<base::Closure, bool>> tasks_to_post_from_nested_loop;
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&TestTask, 1, &run_order), true));
 
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 0, &run_order));
   runners_[0]->PostTask(
-      FROM_HERE,
-      base::Bind(&PostFromNestedRunloop, message_loop_.get(), runners_[0],
-                 base::Unretained(&tasks_to_post_from_nested_loop)));
+      FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(),
+                            base::RetainedRef(runners_[0]),
+                            base::Unretained(&tasks_to_post_from_nested_loop)));
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 
   message_loop_->RunUntilIdle();
 
   EXPECT_THAT(run_order, ElementsAre(0, 2, 1));
 }
 
 TEST_F(TaskQueueManagerTest, WorkBatching) {
   Initialize(1u);
 
@@ skipping 556 matching lines @@
 }
 
 TEST_F(TaskQueueManagerTest, QuitWhileNested) {
   // This test makes sure we don't continue running a work batch after a nested
   // run loop has been exited in the middle of the batch.
   InitializeWithRealMessageLoop(1u);
   manager_->SetWorkBatchSize(2);
 
   bool was_nested = true;
   base::RunLoop run_loop;
-  runners_[0]->PostTask(
-      FROM_HERE,
-      base::Bind(&PostAndQuitFromNestedRunloop, base::Unretained(&run_loop),
-                 runners_[0], base::Unretained(&was_nested)));
+  runners_[0]->PostTask(FROM_HERE, base::Bind(&PostAndQuitFromNestedRunloop,
+                                              base::Unretained(&run_loop),
+                                              base::RetainedRef(runners_[0]),
+                                              base::Unretained(&was_nested)));
 
   message_loop_->RunUntilIdle();
   EXPECT_FALSE(was_nested);
 }
 
 class SequenceNumberCapturingTaskObserver
     : public base::MessageLoop::TaskObserver {
  public:
   // MessageLoop::TaskObserver overrides.
   void WillProcessTask(const base::PendingTask& pending_task) override {}
@@ skipping 236 matching lines @@
                                 base::Unretained(task_queue.get())),
                      true));
   tasks_to_post_from_nested_loop.push_back(std::make_pair(
       base::Bind(&internal::TaskQueueImpl::UnregisterTaskQueue,
                  base::Unretained(task_queue.get())), true));
   tasks_to_post_from_nested_loop.push_back(
       std::make_pair(base::Bind(&HasOneRefTask, base::Unretained(&log),
                                 base::Unretained(task_queue.get())),
                      true));
   runners_[0]->PostTask(
-      FROM_HERE,
-      base::Bind(&PostFromNestedRunloop, message_loop_.get(), runners_[0],
-                 base::Unretained(&tasks_to_post_from_nested_loop)));
+      FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(),
+                            base::RetainedRef(runners_[0]),
+                            base::Unretained(&tasks_to_post_from_nested_loop)));
   message_loop_->RunUntilIdle();
 
   // Add a final call to HasOneRefTask.  This gives the manager a chance to
   // release its reference, and checks that it has.
   runners_[0]->PostTask(FROM_HERE,
                         base::Bind(&HasOneRefTask, base::Unretained(&log),
                                    base::Unretained(task_queue.get())));
   message_loop_->RunUntilIdle();
 
   EXPECT_THAT(log, ElementsAre(false, false, true));
@@ skipping 364 matching lines @@
       FROM_HERE, base::Bind(&RunloopCurrentlyExecutingTaskQueueTestTask,
                             message_loop_.get(), manager_.get(), &task_sources,
                             &tasks_to_post_from_nested_loop));
 
   message_loop_->RunUntilIdle();
   EXPECT_THAT(task_sources, ElementsAre(queue0, queue1, queue2, queue0));
   EXPECT_EQ(nullptr, manager_->currently_executing_task_queue());
 }
 
 }  // namespace scheduler