Add RetainedRef uses where needed.

chrome/browser/sync_file_system/local/local_file_sync_context.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/local_file_sync_context.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
@@ skipping 68 matching lines @@
   callback_queue.push_back(callback);
   if (callback_queue.size() > 1)
     return;
 
   // The sync service always expects the origin (app) is initialized
   // for writable way (even when MaybeInitializeFileSystemContext is called
   // from read-only OpenFileSystem), so open the filesystem with
   // CREATE_IF_NONEXISTENT here.
   storage::FileSystemBackend::OpenFileSystemCallback open_filesystem_callback =
       base::Bind(&LocalFileSyncContext::InitializeFileSystemContextOnIOThread,
-                 this,
-                 source_url,
-                 make_scoped_refptr(file_system_context));
+                 this, source_url, base::RetainedRef(file_system_context));
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&storage::SandboxFileSystemBackendDelegate::OpenFileSystem,
                  base::Unretained(file_system_context->sandbox_delegate()),
                  source_url,
                  storage::kFileSystemTypeSyncable,
                  storage::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT,
                  open_filesystem_callback,
                  GURL()));
 }
 
 void LocalFileSyncContext::ShutdownOnUIThread() {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   shutdown_on_ui_ = true;
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&LocalFileSyncContext::ShutdownOnIOThread, this));
 }
 
 void LocalFileSyncContext::GetFileForLocalSync(
     FileSystemContext* file_system_context,
     const LocalFileSyncInfoCallback& callback) {
   DCHECK(file_system_context);
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 
   base::PostTaskAndReplyWithResult(
-      file_system_context->default_file_task_runner(),
-      FROM_HERE,
-      base::Bind(&LocalFileSyncContext::GetNextURLsForSyncOnFileThread,
-                 this, make_scoped_refptr(file_system_context)),
-      base::Bind(&LocalFileSyncContext::TryPrepareForLocalSync,
-                 this, make_scoped_refptr(file_system_context), callback));
+      file_system_context->default_file_task_runner(), FROM_HERE,
+      base::Bind(&LocalFileSyncContext::GetNextURLsForSyncOnFileThread, this,
+                 base::RetainedRef(file_system_context)),
+      base::Bind(&LocalFileSyncContext::TryPrepareForLocalSync, this,
+                 base::RetainedRef(file_system_context), callback));
 }
 
 void LocalFileSyncContext::ClearChangesForURL(
     FileSystemContext* file_system_context,
     const FileSystemURL& url,
     const base::Closure& done_callback) {
   // This is initially called on UI thread and to be relayed to FILE thread.
   DCHECK(file_system_context);
   if (!file_system_context->default_file_task_runner()->
           RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     file_system_context->default_file_task_runner()->PostTask(
         FROM_HERE,
-        base::Bind(&LocalFileSyncContext::ClearChangesForURL,
-                   this, make_scoped_refptr(file_system_context),
-                   url, done_callback));
+        base::Bind(&LocalFileSyncContext::ClearChangesForURL, this,
+                   base::RetainedRef(file_system_context), url, done_callback));
     return;
   }
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
   backend->change_tracker()->ClearChangesForURL(url);
 
   // Call the completion callback on UI thread.
   ui_task_runner_->PostTask(FROM_HERE, done_callback);
 }
 
 void LocalFileSyncContext::FinalizeSnapshotSync(
     storage::FileSystemContext* file_system_context,
     const storage::FileSystemURL& url,
     SyncStatusCode sync_finish_status,
     const base::Closure& done_callback) {
   DCHECK(file_system_context);
   DCHECK(url.is_valid());
   if (!file_system_context->default_file_task_runner()->
           RunsTasksOnCurrentThread()) {
     file_system_context->default_file_task_runner()->PostTask(
-        FROM_HERE,
-        base::Bind(&LocalFileSyncContext::FinalizeSnapshotSync,
-                   this, make_scoped_refptr(file_system_context),
-                   url, sync_finish_status, done_callback));
+        FROM_HERE, base::Bind(&LocalFileSyncContext::FinalizeSnapshotSync, this,
+                              base::RetainedRef(file_system_context), url,
+                              sync_finish_status, done_callback));
     return;
   }
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
 
   if (sync_finish_status == SYNC_STATUS_OK ||
       sync_finish_status == SYNC_STATUS_HAS_CONFLICT) {
@@ skipping 21 matching lines @@
     const base::Closure& done_callback) {
   DCHECK(file_system_context);
   if (!url.is_valid()) {
     done_callback.Run();
     return;
   }
 
   if (clear_local_changes) {
     ClearChangesForURL(file_system_context, url,
                        base::Bind(&LocalFileSyncContext::FinalizeExclusiveSync,
-                                  this, make_scoped_refptr(file_system_context),
+                                  this, base::RetainedRef(file_system_context),
                                   url, false, done_callback));
     return;
   }
 
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&LocalFileSyncContext::ClearSyncFlagOnIOThread,
                  this, url, false /* for_snapshot_sync */));
 
   done_callback.Run();
 }
 
 void LocalFileSyncContext::PrepareForSync(
     FileSystemContext* file_system_context,
     const FileSystemURL& url,
     SyncMode sync_mode,
     const LocalFileSyncInfoCallback& callback) {
   // This is initially called on UI thread and to be relayed to IO thread.
   if (!io_task_runner_->RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     io_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&LocalFileSyncContext::PrepareForSync, this,
-                   make_scoped_refptr(file_system_context), url,
-                   sync_mode, callback));
+        FROM_HERE, base::Bind(&LocalFileSyncContext::PrepareForSync, this,
+                              base::RetainedRef(file_system_context), url,
+                              sync_mode, callback));
     return;
   }
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   const bool syncable = sync_status()->IsSyncable(url);
   // Disable writing if it's ready to be synced.
   if (syncable)
     sync_status()->StartSyncing(url);
   ui_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&LocalFileSyncContext::DidGetWritingStatusForSync,
-                 this, make_scoped_refptr(file_system_context),
-                 syncable ? SYNC_STATUS_OK :
-                            SYNC_STATUS_FILE_BUSY,
-                 url, sync_mode, callback));
+      FROM_HERE, base::Bind(&LocalFileSyncContext::DidGetWritingStatusForSync,
+                            this, base::RetainedRef(file_system_context),
+                            syncable ? SYNC_STATUS_OK : SYNC_STATUS_FILE_BUSY,
+                            url, sync_mode, callback));
 }
 
 void LocalFileSyncContext::RegisterURLForWaitingSync(
     const FileSystemURL& url,
     const base::Closure& on_syncable_callback) {
   // This is initially called on UI thread and to be relayed to IO thread.
   if (!io_task_runner_->RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     io_task_runner_->PostTask(
         FROM_HERE,
@@ skipping 15 matching lines @@
 
 void LocalFileSyncContext::ApplyRemoteChange(
     FileSystemContext* file_system_context,
     const FileChange& change,
     const base::FilePath& local_path,
     const FileSystemURL& url,
     const SyncStatusCallback& callback) {
   if (!io_task_runner_->RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     io_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&LocalFileSyncContext::ApplyRemoteChange, this,
-                   make_scoped_refptr(file_system_context),
-                   change, local_path, url, callback));
+        FROM_HERE, base::Bind(&LocalFileSyncContext::ApplyRemoteChange, this,
+                              base::RetainedRef(file_system_context), change,
+                              local_path, url, callback));
     return;
   }
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!sync_status()->IsWritable(url));
   DCHECK(!sync_status()->IsWriting(url));
 
   FileSystemOperation::StatusCallback operation_callback;
   switch (change.change()) {
     case FileChange::FILE_CHANGE_DELETE:
       HandleRemoteDelete(file_system_context, url, callback);
@@ skipping 42 matching lines @@
 
   if (storage::VirtualPath::IsRootPath(url.path())) {
     DidApplyRemoteChange(url, callback, base::File::FILE_OK);
     return;
   }
 
   file_system_context->operation_runner()->Remove(
       url_for_sync, true /* recursive */,
       base::Bind(
           &LocalFileSyncContext::DidRemoveExistingEntryForRemoteAddOrUpdate,
-          this,
-          make_scoped_refptr(file_system_context),
-          change,
-          local_path,
-          url,
+          this, base::RetainedRef(file_system_context), change, local_path, url,
           callback));
 }
 
 void LocalFileSyncContext::DidRemoveExistingEntryForRemoteAddOrUpdate(
     FileSystemContext* file_system_context,
     const FileChange& change,
     const base::FilePath& local_path,
     const FileSystemURL& url,
     const SyncStatusCallback& callback,
     base::File::Error error) {
@@ skipping 23 matching lines @@
           storage::VirtualPath::DirName(dir_path) == dir_path) {
         // Copying into the root directory.
         file_system_context->operation_runner()->CopyInForeignFile(
             local_path, url_for_sync, operation_callback);
       } else {
         FileSystemURL dir_url = file_system_context->CreateCrackedFileSystemURL(
             url_for_sync.origin(),
             url_for_sync.mount_type(),
             storage::VirtualPath::DirName(url_for_sync.virtual_path()));
         file_system_context->operation_runner()->CreateDirectory(
-            dir_url,
-            false /* exclusive */,
-            true /* recursive */,
-            base::Bind(&LocalFileSyncContext::DidCreateDirectoryForCopyIn,
-                       this,
-                       make_scoped_refptr(file_system_context),
-                       local_path,
-                       url,
+            dir_url, false /* exclusive */, true /* recursive */,
+            base::Bind(&LocalFileSyncContext::DidCreateDirectoryForCopyIn, this,
+                       base::RetainedRef(file_system_context), local_path, url,
                        operation_callback));
       }
       break;
     }
     case SYNC_FILE_TYPE_DIRECTORY:
       file_system_context->operation_runner()->CreateDirectory(
           url_for_sync, false /* exclusive */, true /* recursive */,
           operation_callback);
       break;
     case SYNC_FILE_TYPE_UNKNOWN:
       NOTREACHED() << "File type unknown for ADD_OR_UPDATE change";
   }
 }
 
 void LocalFileSyncContext::RecordFakeLocalChange(
     FileSystemContext* file_system_context,
     const FileSystemURL& url,
     const FileChange& change,
     const SyncStatusCallback& callback) {
   // This is called on UI thread and to be relayed to FILE thread.
   DCHECK(file_system_context);
   if (!file_system_context->default_file_task_runner()->
           RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     file_system_context->default_file_task_runner()->PostTask(
-        FROM_HERE,
-        base::Bind(&LocalFileSyncContext::RecordFakeLocalChange,
-                   this, make_scoped_refptr(file_system_context),
-                   url, change, callback));
+        FROM_HERE, base::Bind(&LocalFileSyncContext::RecordFakeLocalChange,
+                              this, base::RetainedRef(file_system_context), url,
+                              change, callback));
     return;
   }
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
   backend->change_tracker()->MarkDirtyOnDatabase(url);
   backend->change_tracker()->RecordChange(url, change);
 
   // Fire the callback on UI thread.
   ui_task_runner_->PostTask(FROM_HERE,
                             base::Bind(callback,
                                        SYNC_STATUS_OK));
 }
 
 void LocalFileSyncContext::GetFileMetadata(
     FileSystemContext* file_system_context,
     const FileSystemURL& url,
     const SyncFileMetadataCallback& callback) {
   // This is initially called on UI thread and to be relayed to IO thread.
   if (!io_task_runner_->RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     io_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&LocalFileSyncContext::GetFileMetadata, this,
-                   make_scoped_refptr(file_system_context), url, callback));
+                   base::RetainedRef(file_system_context), url, callback));
     return;
   }
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
 
   FileSystemURL url_for_sync = CreateSyncableFileSystemURLForSync(
       file_system_context, url);
   file_system_context->operation_runner()->GetMetadata(
       url_for_sync, FileSystemOperation::GET_METADATA_FIELD_IS_DIRECTORY |
                         FileSystemOperation::GET_METADATA_FIELD_SIZE |
                         FileSystemOperation::GET_METADATA_FIELD_LAST_MODIFIED,
       base::Bind(&LocalFileSyncContext::DidGetFileMetadata, this, callback));
 }
 
 void LocalFileSyncContext::HasPendingLocalChanges(
     FileSystemContext* file_system_context,
     const FileSystemURL& url,
     const HasPendingLocalChangeCallback& callback) {
   // This gets called on UI thread and relays the task on FILE thread.
   DCHECK(file_system_context);
   if (!file_system_context->default_file_task_runner()->
           RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     file_system_context->default_file_task_runner()->PostTask(
         FROM_HERE,
-        base::Bind(&LocalFileSyncContext::HasPendingLocalChanges,
-                   this, make_scoped_refptr(file_system_context),
-                   url, callback));
+        base::Bind(&LocalFileSyncContext::HasPendingLocalChanges, this,
+                   base::RetainedRef(file_system_context), url, callback));
     return;
   }
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
   FileChangeList changes;
   backend->change_tracker()->GetChangesForURL(url, &changes);
 
   // Fire the callback on UI thread.
   ui_task_runner_->PostTask(FROM_HERE,
                             base::Bind(callback,
                                        SYNC_STATUS_OK,
                                        !changes.empty()));
 }
 
 void LocalFileSyncContext::PromoteDemotedChanges(
     const GURL& origin,
     storage::FileSystemContext* file_system_context,
     const base::Closure& callback) {
   // This is initially called on UI thread and to be relayed to FILE thread.
   DCHECK(file_system_context);
   if (!file_system_context->default_file_task_runner()->
           RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     file_system_context->default_file_task_runner()->PostTask(
         FROM_HERE,
-        base::Bind(&LocalFileSyncContext::PromoteDemotedChanges,
-                   this, origin, make_scoped_refptr(file_system_context),
-                   callback));
+        base::Bind(&LocalFileSyncContext::PromoteDemotedChanges, this, origin,
+                   base::RetainedRef(file_system_context), callback));
     return;
   }
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
   if (!backend->change_tracker()->PromoteDemotedChanges()) {
     ui_task_runner_->PostTask(FROM_HERE, callback);
     return;
@@ skipping 129 matching lines @@
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   if (!backend->change_tracker()) {
     // Create and initialize LocalFileChangeTracker and call back this method
     // later again.
     std::set<GURL>* origins_with_changes = new std::set<GURL>;
     scoped_ptr<LocalFileChangeTracker>* tracker_ptr(
         new scoped_ptr<LocalFileChangeTracker>);
     base::PostTaskAndReplyWithResult(
-        file_system_context->default_file_task_runner(),
-        FROM_HERE,
+        file_system_context->default_file_task_runner(), FROM_HERE,
         base::Bind(&LocalFileSyncContext::InitializeChangeTrackerOnFileThread,
-                   this, tracker_ptr,
-                   make_scoped_refptr(file_system_context),
+                   this, tracker_ptr, base::RetainedRef(file_system_context),
                    origins_with_changes),
         base::Bind(&LocalFileSyncContext::DidInitializeChangeTrackerOnIOThread,
-                   this, base::Owned(tracker_ptr),
-                   source_url,
-                   make_scoped_refptr(file_system_context),
+                   this, base::Owned(tracker_ptr), source_url,
+                   base::RetainedRef(file_system_context),
                    base::Owned(origins_with_changes)));
     return;
   }
   if (!operation_runner_) {
     DCHECK(!sync_status_);
     DCHECK(!timer_on_io_);
     sync_status_.reset(new LocalFileSyncStatus);
     timer_on_io_.reset(new base::OneShotTimer);
     operation_runner_.reset(new SyncableFileOperationRunner(
             kMaxConcurrentSyncableOperation,
@@ skipping 64 matching lines @@
                                         base::File::FILE_OK);
 }
 
 void LocalFileSyncContext::DidInitialize(
     const GURL& source_url,
     FileSystemContext* file_system_context,
     SyncStatusCode status) {
   if (!ui_task_runner_->RunsTasksOnCurrentThread()) {
     ui_task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&LocalFileSyncContext::DidInitialize,
-                   this, source_url,
-                   make_scoped_refptr(file_system_context), status));
+        base::Bind(&LocalFileSyncContext::DidInitialize, this, source_url,
+                   base::RetainedRef(file_system_context), status));
     return;
   }
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!ContainsKey(file_system_contexts_, file_system_context));
   DCHECK(ContainsKey(pending_initialize_callbacks_, file_system_context));
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
@@ skipping 44 matching lines @@
   if (urls->empty()) {
     callback.Run(SYNC_STATUS_NO_CHANGE_TO_SYNC,
                  LocalFileSyncInfo(),
                  storage::ScopedFile());
     return;
   }
 
   const FileSystemURL url = urls->front();
   urls->pop_front();
 
-  PrepareForSync(
-      file_system_context, url, SYNC_SNAPSHOT,
-      base::Bind(&LocalFileSyncContext::DidTryPrepareForLocalSync,
-                 this, make_scoped_refptr(file_system_context),
-                 base::Passed(&urls), callback));
+  PrepareForSync(file_system_context, url, SYNC_SNAPSHOT,
+                 base::Bind(&LocalFileSyncContext::DidTryPrepareForLocalSync,
+                            this, base::RetainedRef(file_system_context),
+                            base::Passed(&urls), callback));
 }
 
 void LocalFileSyncContext::DidTryPrepareForLocalSync(
     FileSystemContext* file_system_context,
     scoped_ptr<FileSystemURLQueue> remaining_urls,
     const LocalFileSyncInfoCallback& callback,
     SyncStatusCode status,
     const LocalFileSyncInfo& sync_file_info,
     storage::ScopedFile snapshot) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
@@ skipping 15 matching lines @@
     FileSystemContext* file_system_context,
     const FileSystemURL& url) {
   DCHECK(file_system_context);
   if (!file_system_context->default_file_task_runner()->
           RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     if (shutdown_on_ui_)
       return;
     file_system_context->default_file_task_runner()->PostTask(
         FROM_HERE,
-        base::Bind(&LocalFileSyncContext::PromoteDemotedChangesForURL,
-                   this, make_scoped_refptr(file_system_context), url));
+        base::Bind(&LocalFileSyncContext::PromoteDemotedChangesForURL, this,
+                   base::RetainedRef(file_system_context), url));
     return;
   }
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
   backend->change_tracker()->PromoteDemotedChangesForURL(url);
 }
 
 void LocalFileSyncContext::PromoteDemotedChangesForURLs(
     FileSystemContext* file_system_context,
     scoped_ptr<FileSystemURLQueue> urls) {
   DCHECK(file_system_context);
   if (!file_system_context->default_file_task_runner()->
           RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     if (shutdown_on_ui_)
       return;
     file_system_context->default_file_task_runner()->PostTask(
         FROM_HERE,
-        base::Bind(&LocalFileSyncContext::PromoteDemotedChangesForURLs,
-                   this, make_scoped_refptr(file_system_context),
+        base::Bind(&LocalFileSyncContext::PromoteDemotedChangesForURLs, this,
+                   base::RetainedRef(file_system_context),
                    base::Passed(&urls)));
     return;
   }
 
   for (FileSystemURLQueue::iterator iter = urls->begin();
        iter != urls->end(); ++iter)
     PromoteDemotedChangesForURL(file_system_context, *iter);
 }
 
 void LocalFileSyncContext::DidGetWritingStatusForSync(
     FileSystemContext* file_system_context,
     SyncStatusCode status,
     const FileSystemURL& url,
     SyncMode sync_mode,
     const LocalFileSyncInfoCallback& callback) {
   // This gets called on UI thread and relays the task on FILE thread.
   DCHECK(file_system_context);
   if (!file_system_context->default_file_task_runner()->
           RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     if (shutdown_on_ui_) {
       callback.Run(
           SYNC_STATUS_ABORT, LocalFileSyncInfo(), storage::ScopedFile());
       return;
     }
     file_system_context->default_file_task_runner()->PostTask(
-        FROM_HERE,
-        base::Bind(&LocalFileSyncContext::DidGetWritingStatusForSync,
-                   this, make_scoped_refptr(file_system_context),
-                   status, url, sync_mode, callback));
+        FROM_HERE, base::Bind(&LocalFileSyncContext::DidGetWritingStatusForSync,
+                              this, base::RetainedRef(file_system_context),
+                              status, url, sync_mode, callback));
     return;
   }
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
   FileChangeList changes;
   backend->change_tracker()->GetChangesForURL(url, &changes);
 
@@ skipping 142 matching lines @@
     return;
   }
 
   FileSystemURL url_for_sync = CreateSyncableFileSystemURLForSync(
       file_system_context, dest_url);
   file_system_context->operation_runner()->CopyInForeignFile(
       local_path, url_for_sync, callback);
 }
 
 }  // namespace sync_file_system