Rewrite base::Bind to base::BindOnce with base_bind_rewriters in //chrome/browser/sync_file_system

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 53 matching lines @@
 }
 
 void LocalFileSyncContext::MaybeInitializeFileSystemContext(
     const GURL& source_url,
     FileSystemContext* file_system_context,
     const SyncStatusCallback& callback) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   if (base::ContainsKey(file_system_contexts_, file_system_context)) {
     // The context has been already initialized. Just dispatch the callback
     // with SYNC_STATUS_OK.
-    ui_task_runner_->PostTask(FROM_HERE, base::Bind(callback, SYNC_STATUS_OK));
+    ui_task_runner_->PostTask(FROM_HERE,
+                              base::BindOnce(callback, SYNC_STATUS_OK));
     return;
   }
 
   StatusCallbackQueue& callback_queue =
       pending_initialize_callbacks_[file_system_context];
   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, 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()));
+      base::BindOnce(&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));
+      base::BindOnce(&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,
                  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,
-                   base::RetainedRef(file_system_context), url, done_callback));
+        FROM_HERE, base::BindOnce(&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,
-                              base::RetainedRef(file_system_context), url,
-                              sync_finish_status, done_callback));
+        FROM_HERE, base::BindOnce(&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) {
     // Commit the in-memory mirror change.
     backend->change_tracker()->ResetToMirrorAndCommitChangesForURL(url);
   } else {
     // Abort in-memory mirror change.
     backend->change_tracker()->RemoveMirrorAndCommitChangesForURL(url);
   }
 
   // We've been keeping it in writing mode, so clear the writing counter
   // to unblock sync activities.
   io_task_runner_->PostTask(
-      FROM_HERE, base::Bind(
-          &LocalFileSyncContext::FinalizeSnapshotSyncOnIOThread, this, url));
+      FROM_HERE,
+      base::BindOnce(&LocalFileSyncContext::FinalizeSnapshotSyncOnIOThread,
+                     this, url));
 
   // Call the completion callback on UI thread.
   ui_task_runner_->PostTask(FROM_HERE, done_callback);
 }
 
 void LocalFileSyncContext::FinalizeExclusiveSync(
     storage::FileSystemContext* file_system_context,
     const storage::FileSystemURL& url,
     bool clear_local_changes,
     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, 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 */));
+      FROM_HERE, base::BindOnce(&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,
-                              base::RetainedRef(file_system_context), url,
-                              sync_mode, callback));
+        FROM_HERE, base::BindOnce(&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, base::RetainedRef(file_system_context),
-                            syncable ? SYNC_STATUS_OK : SYNC_STATUS_FILE_BUSY,
-                            url, sync_mode, callback));
+      FROM_HERE,
+      base::BindOnce(&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,
-        base::Bind(&LocalFileSyncContext::RegisterURLForWaitingSync,
-                   this, url, on_syncable_callback));
+        base::BindOnce(&LocalFileSyncContext::RegisterURLForWaitingSync, this,
+                       url, on_syncable_callback));
     return;
   }
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   if (shutdown_on_io_)
     return;
   if (sync_status()->IsSyncable(url)) {
     // No need to register; fire the callback now.
     ui_task_runner_->PostTask(FROM_HERE, on_syncable_callback);
     return;
   }
   url_waiting_sync_on_io_ = url;
   url_syncable_callback_ = on_syncable_callback;
 }
 
 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,
-                              base::RetainedRef(file_system_context), change,
-                              local_path, url, callback));
+        FROM_HERE, base::BindOnce(&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 114 matching lines @@
     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, base::RetainedRef(file_system_context), url,
-                              change, callback));
+        FROM_HERE, base::BindOnce(&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));
+                            base::BindOnce(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,
-                   base::RetainedRef(file_system_context), url, callback));
+        base::BindOnce(&LocalFileSyncContext::GetFileMetadata, this,
+                       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,
-                   base::RetainedRef(file_system_context), url, callback));
+        base::BindOnce(&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()));
+  ui_task_runner_->PostTask(
+      FROM_HERE, base::BindOnce(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,
-                   base::RetainedRef(file_system_context), callback));
+        base::BindOnce(&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;
   }
 
   io_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&LocalFileSyncContext::UpdateChangesForOrigin,
-                 this, origin, callback));
+      FROM_HERE, base::BindOnce(&LocalFileSyncContext::UpdateChangesForOrigin,
+                                this, origin, callback));
 }
 
 void LocalFileSyncContext::UpdateChangesForOrigin(
     const GURL& origin,
     const base::Closure& callback) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   if (shutdown_on_io_)
     return;
   origins_with_pending_changes_.insert(origin);
   ScheduleNotifyChangesUpdatedOnIOThread(callback);
@@ skipping 63 matching lines @@
 void LocalFileSyncContext::NotifyAvailableChangesOnIOThread() {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   if (shutdown_on_io_)
     return;
 
   std::vector<base::Closure> completion_callbacks;
   completion_callbacks.swap(pending_completion_callbacks_);
 
   ui_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&LocalFileSyncContext::NotifyAvailableChanges,
-                 this, origins_with_pending_changes_,
-                 completion_callbacks));
+      base::BindOnce(&LocalFileSyncContext::NotifyAvailableChanges, this,
+                     origins_with_pending_changes_, completion_callbacks));
   last_notified_changes_ = base::Time::Now();
   origins_with_pending_changes_.clear();
 }
 
 void LocalFileSyncContext::NotifyAvailableChanges(
     const std::set<GURL>& origins,
     const std::vector<base::Closure>& callbacks) {
   for (auto& observer : origin_change_observers_)
     observer.OnChangesAvailableInOrigins(origins);
   for (const auto& callback : callbacks)
@@ skipping 118 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,
-                   base::RetainedRef(file_system_context), status));
+        base::BindOnce(&LocalFileSyncContext::DidInitialize, this, source_url,
+                       base::RetainedRef(file_system_context), status));
     return;
   }
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!base::ContainsKey(file_system_contexts_, file_system_context));
   DCHECK(base::ContainsKey(pending_initialize_callbacks_, file_system_context));
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
 
   file_system_contexts_.insert(file_system_context);
 
   StatusCallbackQueue& callback_queue =
       pending_initialize_callbacks_[file_system_context];
   for (StatusCallbackQueue::iterator iter = callback_queue.begin();
        iter != callback_queue.end(); ++iter) {
-    ui_task_runner_->PostTask(FROM_HERE, base::Bind(*iter, status));
+    ui_task_runner_->PostTask(FROM_HERE, base::BindOnce(*iter, status));
   }
   pending_initialize_callbacks_.erase(file_system_context);
 }
 
 std::unique_ptr<LocalFileSyncContext::FileSystemURLQueue>
 LocalFileSyncContext::GetNextURLsForSyncOnFileThread(
     FileSystemContext* file_system_context) {
   DCHECK(file_system_context);
   DCHECK(file_system_context->default_file_task_runner()->
              RunsTasksOnCurrentThread());
@@ skipping 65 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,
-                   base::RetainedRef(file_system_context), url));
+        base::BindOnce(&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,
     std::unique_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,
-                   base::RetainedRef(file_system_context),
-                   base::Passed(&urls)));
+        base::BindOnce(&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, base::RetainedRef(file_system_context),
-                              status, url, sync_mode, callback));
+        FROM_HERE,
+        base::BindOnce(&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 49 matching lines @@
       // changes to both mirror and original records during sync), so that
       // we can reset to the mirror when the sync succeeds.
       backend->change_tracker()->CreateFreshMirrorForURL(url);
     }
 
     // 'Unlock' the file for snapshot sync.
     // (But keep it in writing status so that no other sync starts on
     // the same URL)
     io_task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&LocalFileSyncContext::ClearSyncFlagOnIOThread,
-                   this, url, true /* for_snapshot_sync */));
+        base::BindOnce(&LocalFileSyncContext::ClearSyncFlagOnIOThread, this,
+                       url, true /* for_snapshot_sync */));
   }
 
   ui_task_runner_->PostTask(FROM_HERE,
-                            base::Bind(callback, status, sync_file_info,
-                                       base::Passed(&snapshot)));
+                            base::BindOnce(callback, status, sync_file_info,
+                                           base::Passed(&snapshot)));
 }
 
 void LocalFileSyncContext::ClearSyncFlagOnIOThread(
     const FileSystemURL& url,
     bool for_snapshot_sync) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   if (shutdown_on_io_)
     return;
   sync_status()->EndSyncing(url);
 
@@ skipping 19 matching lines @@
 }
 
 void LocalFileSyncContext::DidApplyRemoteChange(
     const FileSystemURL& url,
     const SyncStatusCallback& callback_on_ui,
     base::File::Error file_error) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   root_delete_helper_.reset();
   ui_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(callback_on_ui, FileErrorToSyncStatusCode(file_error)));
+      base::BindOnce(callback_on_ui, FileErrorToSyncStatusCode(file_error)));
 }
 
 void LocalFileSyncContext::DidGetFileMetadata(
     const SyncFileMetadataCallback& callback,
     base::File::Error file_error,
     const base::File::Info& file_info) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   SyncFileMetadata metadata;
   if (file_error == base::File::FILE_OK) {
     metadata.file_type = file_info.is_directory ?
         SYNC_FILE_TYPE_DIRECTORY : SYNC_FILE_TYPE_FILE;
     metadata.size = file_info.size;
     metadata.last_modified = file_info.last_modified;
   }
   ui_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(callback, FileErrorToSyncStatusCode(file_error), metadata));
+      FROM_HERE, base::BindOnce(callback, FileErrorToSyncStatusCode(file_error),
+                                metadata));
 }
 
 base::TimeDelta LocalFileSyncContext::NotifyChangesDuration() {
   if (mock_notify_changes_duration_in_sec_ >= 0)
     return base::TimeDelta::FromSeconds(mock_notify_changes_duration_in_sec_);
   return base::TimeDelta::FromSeconds(kNotifyChangesDurationInSec);
 }
 
 void LocalFileSyncContext::DidCreateDirectoryForCopyIn(
     FileSystemContext* file_system_context,
     const base::FilePath& local_path,
     const FileSystemURL& dest_url,
     const StatusCallback& callback,
     base::File::Error error) {
   if (error != base::File::FILE_OK) {
     callback.Run(error);
     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