Add RetainedRef uses where needed.

storage/browser/fileapi/file_system_quota_client.cc

 // Copyright (c) 2012 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 "storage/browser/fileapi/file_system_quota_client.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
@@ skipping 96 matching lines @@
   FileSystemType type = QuotaStorageTypeToFileSystemType(storage_type);
   DCHECK(type != kFileSystemTypeUnknown);
 
   FileSystemQuotaUtil* quota_util = file_system_context_->GetQuotaUtil(type);
   if (!quota_util) {
     callback.Run(0);
     return;
   }
 
   base::PostTaskAndReplyWithResult(
-      file_task_runner(),
-      FROM_HERE,
+      file_task_runner(), FROM_HERE,
       // It is safe to pass Unretained(quota_util) since context owns it.
       base::Bind(&FileSystemQuotaUtil::GetOriginUsageOnFileTaskRunner,
                  base::Unretained(quota_util),
-                 file_system_context_,
-                 origin_url,
-                 type),
+                 base::RetainedRef(file_system_context_), origin_url, type),
       callback);
 }
 
 void FileSystemQuotaClient::GetOriginsForType(
     StorageType storage_type,
     const GetOriginsCallback& callback) {
   DCHECK(!callback.is_null());
 
   if (is_incognito_) {
     // We don't support FileSystem in incognito mode yet.
     std::set<GURL> origins;
     callback.Run(origins);
     return;
   }
 
   std::set<GURL>* origins_ptr = new std::set<GURL>();
   file_task_runner()->PostTaskAndReply(
-      FROM_HERE,
-      base::Bind(&GetOriginsForTypeOnFileTaskRunner,
-                 file_system_context_,
-                 storage_type,
-                 base::Unretained(origins_ptr)),
-      base::Bind(&DidGetOrigins,
-                 callback,
-                 base::Owned(origins_ptr)));
+      FROM_HERE, base::Bind(&GetOriginsForTypeOnFileTaskRunner,
+                            base::RetainedRef(file_system_context_),
+                            storage_type, base::Unretained(origins_ptr)),
+      base::Bind(&DidGetOrigins, callback, base::Owned(origins_ptr)));
 }
 
 void FileSystemQuotaClient::GetOriginsForHost(
     StorageType storage_type,
     const std::string& host,
     const GetOriginsCallback& callback) {
   DCHECK(!callback.is_null());
 
   if (is_incognito_) {
     // We don't support FileSystem in incognito mode yet.
     std::set<GURL> origins;
     callback.Run(origins);
     return;
   }
 
   std::set<GURL>* origins_ptr = new std::set<GURL>();
   file_task_runner()->PostTaskAndReply(
-      FROM_HERE,
-      base::Bind(&GetOriginsForHostOnFileTaskRunner,
-                 file_system_context_,
-                 storage_type,
-                 host,
-                 base::Unretained(origins_ptr)),
-      base::Bind(&DidGetOrigins,
-                 callback,
-                 base::Owned(origins_ptr)));
+      FROM_HERE, base::Bind(&GetOriginsForHostOnFileTaskRunner,
+                            base::RetainedRef(file_system_context_),
+                            storage_type, host, base::Unretained(origins_ptr)),
+      base::Bind(&DidGetOrigins, callback, base::Owned(origins_ptr)));
 }
 
 void FileSystemQuotaClient::DeleteOriginData(
     const GURL& origin,
     StorageType type,
     const DeletionCallback& callback) {
   FileSystemType fs_type = QuotaStorageTypeToFileSystemType(type);
   DCHECK(fs_type != kFileSystemTypeUnknown);
 
   base::PostTaskAndReplyWithResult(
-      file_task_runner(),
-      FROM_HERE,
+      file_task_runner(), FROM_HERE,
       base::Bind(&DeleteOriginOnFileTaskRunner,
-                 file_system_context_,
-                 origin,
-                 fs_type),
+                 base::RetainedRef(file_system_context_), origin, fs_type),
       callback);
 }
 
 bool FileSystemQuotaClient::DoesSupport(
     storage::StorageType storage_type) const {
   FileSystemType type = QuotaStorageTypeToFileSystemType(storage_type);
   DCHECK(type != kFileSystemTypeUnknown);
   return file_system_context_->IsSandboxFileSystem(type);
 }
 
 base::SequencedTaskRunner* FileSystemQuotaClient::file_task_runner() const {
   return file_system_context_->default_file_task_runner();
 }
 
 }  // namespace storage