Add RetainedRef uses where needed.

content/child/fileapi/webfilesystem_impl.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 "content/child/fileapi/webfilesystem_impl.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 86 matching lines @@
 template <typename Method, typename Params>
 void CallDispatcherOnMainThread(
     const scoped_refptr<base::SingleThreadTaskRunner>& main_thread_task_runner,
     Method method, const Params& params,
     WaitableCallbackResults* waitable_results) {
   if (!main_thread_task_runner->RunsTasksOnCurrentThread()) {
     main_thread_task_runner->PostTask(
         FROM_HERE,
         base::Bind(&CallDispatcherOnMainThread<Method, Params>,
                    main_thread_task_runner, method, params,
-                   scoped_refptr<WaitableCallbackResults>()));
+                   base::RetainedRef<WaitableCallbackResults>(nullptr)));

[Nico, 2016/03/18 21:01:01]

ditto

     if (!waitable_results)
       return;
     waitable_results->WaitAndRun();
   }
   if (!ChildThreadImpl::current() ||
       !ChildThreadImpl::current()->file_system_dispatcher())
     return;
 
   DCHECK(!waitable_results);
   DispatchToMethod(ChildThreadImpl::current()->file_system_dispatcher(),
@@ skipping 299 matching lines @@
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::OpenFileSystem,
       MakeTuple(GURL(storage_partition),
                 static_cast<storage::FileSystemType>(type),
                 base::Bind(&OpenFileSystemCallbackAdapter,
                            base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           waitable_results),
+                           base::RetainedRef(waitable_results)),
                 base::Bind(&StatusCallbackAdapter,
                            base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           waitable_results)),
+                           base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::resolveURL(
     const blink::WebURL& filesystem_url,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::ResolveURL,
       MakeTuple(GURL(filesystem_url),
                 base::Bind(&ResolveURLCallbackAdapter,
                            base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           waitable_results),
+                           base::RetainedRef(waitable_results)),
                 base::Bind(&StatusCallbackAdapter,
                            base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           waitable_results)),
+                           base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::deleteFileSystem(
     const blink::WebURL& storage_partition,
     blink::WebFileSystemType type,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::DeleteFileSystem,
       MakeTuple(GURL(storage_partition),
                 static_cast<storage::FileSystemType>(type),
                 base::Bind(&StatusCallbackAdapter,
                            base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           waitable_results)),
+                           base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::move(
     const blink::WebURL& src_path,
     const blink::WebURL& dest_path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::Move,
       MakeTuple(GURL(src_path), GURL(dest_path),
                 base::Bind(&StatusCallbackAdapter,
                            base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           waitable_results)),
+                           base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::copy(
     const blink::WebURL& src_path,
     const blink::WebURL& dest_path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::Copy,
       MakeTuple(GURL(src_path), GURL(dest_path),
                 base::Bind(&StatusCallbackAdapter,
                            base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           waitable_results)),
+                           base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::remove(
     const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::Remove,
       MakeTuple(GURL(path), false /* recursive */,
                 base::Bind(&StatusCallbackAdapter,
                            base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           waitable_results)),
+                           base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::removeRecursively(
     const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::Remove,
       MakeTuple(GURL(path), true /* recursive */,
                 base::Bind(&StatusCallbackAdapter,
                            base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           waitable_results)),
+                           base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::readMetadata(
     const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::ReadMetadata,
-      MakeTuple(GURL(path), base::Bind(&ReadMetadataCallbackAdapter,
-                                       base::ThreadTaskRunnerHandle::Get(),
-                                       callbacks_id, waitable_results),
+      MakeTuple(GURL(path),
+                base::Bind(&ReadMetadataCallbackAdapter,
+                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                           base::RetainedRef(waitable_results)),
                 base::Bind(&StatusCallbackAdapter,
                            base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           waitable_results)),
+                           base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::createFile(
     const blink::WebURL& path,
     bool exclusive,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::CreateFile,
       MakeTuple(GURL(path), exclusive,
                 base::Bind(&StatusCallbackAdapter,
                            base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           waitable_results)),
+                           base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::createDirectory(
     const blink::WebURL& path,
     bool exclusive,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::CreateDirectory,
       MakeTuple(GURL(path), exclusive, false /* recursive */,
                 base::Bind(&StatusCallbackAdapter,
                            base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           waitable_results)),
+                           base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::fileExists(
     const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::Exists,
       MakeTuple(GURL(path), false /* directory */,
                 base::Bind(&StatusCallbackAdapter,
                            base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           waitable_results)),
+                           base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::directoryExists(
     const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::Exists,
       MakeTuple(GURL(path), true /* directory */,
                 base::Bind(&StatusCallbackAdapter,
                            base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           waitable_results)),
+                           base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 int WebFileSystemImpl::readDirectory(
     const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::ReadDirectory,
-      MakeTuple(GURL(path), base::Bind(&ReadDirectoryCallbackAdapter,
-                                       base::ThreadTaskRunnerHandle::Get(),
-                                       callbacks_id, waitable_results),
+      MakeTuple(GURL(path),
+                base::Bind(&ReadDirectoryCallbackAdapter,
+                           base::ThreadTaskRunnerHandle::Get(), callbacks_id,
+                           base::RetainedRef(waitable_results)),
                 base::Bind(&StatusCallbackAdapter,
                            base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           waitable_results)),
+                           base::RetainedRef(waitable_results))),
       waitable_results.get());
   return callbacks_id;
 }
 
 void WebFileSystemImpl::createFileWriter(
     const WebURL& path,
     blink::WebFileWriterClient* client,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::ReadMetadata,
       MakeTuple(GURL(path),
                 base::Bind(&CreateFileWriterCallbackAdapter,
                            base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           waitable_results, main_thread_task_runner_,
-                           GURL(path), client),
+                           base::RetainedRef(waitable_results),
+                           main_thread_task_runner_, GURL(path), client),
                 base::Bind(&StatusCallbackAdapter,
                            base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           waitable_results)),
+                           base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 void WebFileSystemImpl::createSnapshotFileAndReadMetadata(
     const blink::WebURL& path,
     WebFileSystemCallbacks callbacks) {
   int callbacks_id = RegisterCallbacks(callbacks);
   scoped_refptr<WaitableCallbackResults> waitable_results =
       MaybeCreateWaitableResults(callbacks, callbacks_id);
   CallDispatcherOnMainThread(
       main_thread_task_runner_, &FileSystemDispatcher::CreateSnapshotFile,
       MakeTuple(GURL(path),
                 base::Bind(&CreateSnapshotFileCallbackAdapter,
                            base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           waitable_results, main_thread_task_runner_),
+                           base::RetainedRef(waitable_results),
+                           main_thread_task_runner_),
                 base::Bind(&StatusCallbackAdapter,
                            base::ThreadTaskRunnerHandle::Get(), callbacks_id,
-                           waitable_results)),
+                           base::RetainedRef(waitable_results))),
       waitable_results.get());
 }
 
 bool WebFileSystemImpl::waitForAdditionalResult(int callbacksId) {
   WaitableCallbackResultsMap::iterator found =
       waitable_results_.find(callbacksId);
   if (found == waitable_results_.end())
     return false;
 
   found->second->WaitAndRun();
@@ skipping 27 matching lines @@
 WaitableCallbackResults* WebFileSystemImpl::MaybeCreateWaitableResults(
     const WebFileSystemCallbacks& callbacks, int callbacks_id) {
   if (!callbacks.shouldBlockUntilCompletion())
     return NULL;
   WaitableCallbackResults* results = new WaitableCallbackResults();
   waitable_results_[callbacks_id] = results;
   return results;
 }
 
 }  // namespace content