Add RetainedRef uses where needed.

chrome/browser/sync_file_system/local/canned_syncable_file_system.cc

 // Copyright 2013 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 "chrome/browser/sync_file_system/local/canned_syncable_file_system.h"
 
 #include <stddef.h>
 #include <algorithm>
 #include <iterator>
 #include <utility>
@@ skipping 51 matching lines @@
 template <typename R>
 R RunOnThread(
     base::SingleThreadTaskRunner* task_runner,
     const tracked_objects::Location& location,
     const base::Callback<void(const base::Callback<void(R)>& callback)>& task) {
   R result;
   base::RunLoop run_loop;
   task_runner->PostTask(
       location,
       base::Bind(task, base::Bind(&AssignAndQuit<R>,
-                                  base::ThreadTaskRunnerHandle::Get(),
-                                  run_loop.QuitClosure(),
-                                  &result)));
+                                  base::RetainedRef(
+                                      base::ThreadTaskRunnerHandle::Get()),
+                                  run_loop.QuitClosure(), &result)));
   run_loop.Run();
   return result;
 }
 
 void RunOnThread(base::SingleThreadTaskRunner* task_runner,
                  const tracked_objects::Location& location,
                  const base::Closure& task) {
   base::RunLoop run_loop;
   task_runner->PostTaskAndReply(
       location, task,
       base::Bind(base::IgnoreResult(
           base::Bind(&base::SingleThreadTaskRunner::PostTask,
                      base::ThreadTaskRunnerHandle::Get(),
                      FROM_HERE, run_loop.QuitClosure()))));
   run_loop.Run();
 }
 
 void EnsureRunningOn(base::SingleThreadTaskRunner* runner) {
   EXPECT_TRUE(runner->RunsTasksOnCurrentThread());
 }
 
 void VerifySameTaskRunner(
     base::SingleThreadTaskRunner* runner1,
     base::SingleThreadTaskRunner* runner2) {
   ASSERT_TRUE(runner1 != nullptr);
   ASSERT_TRUE(runner2 != nullptr);
   runner1->PostTask(FROM_HERE,
-                    base::Bind(&EnsureRunningOn, make_scoped_refptr(runner2)));
+                    base::Bind(&EnsureRunningOn, base::RetainedRef(runner2)));
 }
 
 void OnCreateSnapshotFileAndVerifyData(
     const std::string& expected_data,
     const CannedSyncableFileSystem::StatusCallback& callback,
     base::File::Error result,
     const base::File::Info& file_info,
     const base::FilePath& platform_path,
     const scoped_refptr<storage::ShareableFileReference>& /* file_ref */) {
   if (result != base::File::FILE_OK) {
@@ skipping 172 matching lines @@
   GURL url(root_url_.spec() + path);
   return file_system_context_->CrackURL(url);
 }
 
 File::Error CannedSyncableFileSystem::OpenFileSystem() {
   EXPECT_TRUE(is_filesystem_set_up_);
 
   base::RunLoop run_loop;
   io_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&CannedSyncableFileSystem::DoOpenFileSystem,
-                 base::Unretained(this),
-                 base::Bind(&CannedSyncableFileSystem::DidOpenFileSystem,
-                            base::Unretained(this),
-                            base::ThreadTaskRunnerHandle::Get(),
-                            run_loop.QuitClosure())));
+      base::Bind(
+          &CannedSyncableFileSystem::DoOpenFileSystem, base::Unretained(this),
+          base::Bind(&CannedSyncableFileSystem::DidOpenFileSystem,
+                     base::Unretained(this),
+                     base::RetainedRef(base::ThreadTaskRunnerHandle::Get()),
+                     run_loop.QuitClosure())));
   run_loop.Run();
 
   if (backend()->sync_context()) {
     // Register 'this' as a sync status observer.
     RunOnThread(
         io_task_runner_.get(),
         FROM_HERE,
         base::Bind(&CannedSyncableFileSystem::InitializeSyncStatusObserver,
                    base::Unretained(this)));
   }
@@ skipping 420 matching lines @@
     const GURL& root,
     const std::string& name,
     File::Error result) {
   if (io_task_runner_->RunsTasksOnCurrentThread()) {
     EXPECT_FALSE(is_filesystem_opened_);
     is_filesystem_opened_ = true;
   }
   if (!original_task_runner->RunsTasksOnCurrentThread()) {
     DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
     original_task_runner->PostTask(
-        FROM_HERE,
-        base::Bind(&CannedSyncableFileSystem::DidOpenFileSystem,
-                   base::Unretained(this),
-                   make_scoped_refptr(original_task_runner),
-                   quit_closure,
-                   root, name, result));
+        FROM_HERE, base::Bind(&CannedSyncableFileSystem::DidOpenFileSystem,
+                              base::Unretained(this),
+                              base::RetainedRef(original_task_runner),
+                              quit_closure, root, name, result));
     return;
   }
   result_ = result;
   root_url_ = root;
   quit_closure.Run();
 }
 
 void CannedSyncableFileSystem::DidInitializeFileSystemContext(
     const base::Closure& quit_closure,
     SyncStatusCode status) {
   sync_status_ = status;
   quit_closure.Run();
 }
 
 void CannedSyncableFileSystem::InitializeSyncStatusObserver() {
   ASSERT_TRUE(io_task_runner_->RunsTasksOnCurrentThread());
   backend()->sync_context()->sync_status()->AddObserver(this);
 }
 
 }  // namespace sync_file_system