Add RetainedRef uses where needed.

chrome/browser/media_galleries/fileapi/device_media_async_file_util.cc

 // Copyright (c) 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/media_galleries/fileapi/device_media_async_file_util.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/callback.h"
@@ skipping 205 matching lines @@
     OnCreateSnapshotFileError(callback, base::File::FILE_ERROR_FAILED);
     return;
   }
   MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(url);
   if (!delegate) {
     OnCreateSnapshotFileError(callback, base::File::FILE_ERROR_NOT_FOUND);
     return;
   }
   delegate->CreateSnapshotFile(
       url.path(),  // device file path
-      snapshot_file_path,
-      base::Bind(&OnDidCreateSnapshotFile,
-                 callback,
-                 make_scoped_refptr(context->task_runner()),
-                 validate_media_files),
+      snapshot_file_path, base::Bind(&OnDidCreateSnapshotFile, callback,
+                                     base::RetainedRef(context->task_runner()),
+                                     validate_media_files),
       base::Bind(&OnCreateSnapshotFileError, callback));
 }
 
 }  // namespace
 
 class DeviceMediaAsyncFileUtil::MediaPathFilterWrapper
     : public base::RefCountedThreadSafe<MediaPathFilterWrapper> {
  public:
   MediaPathFilterWrapper();
 
@@ skipping 71 matching lines @@
   // Returns an error if any unsupported flag is found.
   if (file_flags & ~(base::File::FLAG_OPEN |
                      base::File::FLAG_READ |
                      base::File::FLAG_WRITE_ATTRIBUTES)) {
     callback.Run(base::File(base::File::FILE_ERROR_SECURITY), base::Closure());
     return;
   }
   CreateSnapshotFile(
       std::move(context), url,
       base::Bind(&NativeMediaFileUtil::CreatedSnapshotFileForCreateOrOpen,
-                 make_scoped_refptr(context->task_runner()), file_flags,
+                 base::RetainedRef(context->task_runner()), file_flags,
                  callback));
 }
 
 void DeviceMediaAsyncFileUtil::EnsureFileExists(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const EnsureFileExistsCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   NOTIMPLEMENTED();
   callback.Run(base::File::FILE_ERROR_SECURITY, false);
@@ skipping 26 matching lines @@
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     int /* flags */,
     const GetFileInfoCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(url);
   if (!delegate) {
     OnGetFileInfoError(callback, base::File::FILE_ERROR_NOT_FOUND);
     return;
   }
-  delegate->GetFileInfo(
-      url.path(),
-      base::Bind(&DeviceMediaAsyncFileUtil::OnDidGetFileInfo,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 make_scoped_refptr(context->task_runner()),
-                 url.path(),
-                 callback),
-      base::Bind(&OnGetFileInfoError, callback));
+  delegate->GetFileInfo(url.path(),
+                        base::Bind(&DeviceMediaAsyncFileUtil::OnDidGetFileInfo,
+                                   weak_ptr_factory_.GetWeakPtr(),
+                                   base::RetainedRef(context->task_runner()),
+                                   url.path(), callback),
+                        base::Bind(&OnGetFileInfoError, callback));
 }
 
 void DeviceMediaAsyncFileUtil::ReadDirectory(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const ReadDirectoryCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   MTPDeviceAsyncDelegate* delegate = GetMTPDeviceDelegate(url);
   if (!delegate) {
     OnReadDirectoryError(callback, base::File::FILE_ERROR_NOT_FOUND);
     return;
   }
 
   delegate->ReadDirectory(
       url.path(),
       base::Bind(&DeviceMediaAsyncFileUtil::OnDidReadDirectory,
                  weak_ptr_factory_.GetWeakPtr(),
-                 make_scoped_refptr(context->task_runner()),
-                 callback),
+                 base::RetainedRef(context->task_runner()), callback),
       base::Bind(&OnReadDirectoryError, callback));
 }
 
 void DeviceMediaAsyncFileUtil::Touch(
     scoped_ptr<FileSystemOperationContext> context,
     const FileSystemURL& url,
     const base::Time& last_access_time,
     const base::Time& last_modified_time,
     const StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
@@ skipping 295 matching lines @@
 void DeviceMediaAsyncFileUtil::OnDidDeleteDirectory(
     const StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   callback.Run(base::File::FILE_OK);
 }
 
 bool DeviceMediaAsyncFileUtil::validate_media_files() const {
   return media_path_filter_wrapper_.get() != NULL;
 }