[SyncFS] Add completion callback to PromoteDemotedChanges (1/3)

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 "base/bind.h"
 #include "base/file_util.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 480 matching lines @@
 
   // 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,
-    fileapi::FileSystemContext* file_system_context) {
+    fileapi::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)));
+                   this, origin, make_scoped_refptr(file_system_context),
+                   callback));
     return;
   }
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
-  if (!backend->change_tracker()->PromoteDemotedChanges())
+  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));
+                 this, origin, callback));
 }
 
-void LocalFileSyncContext::UpdateChangesForOrigin(const GURL& origin) {
+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();
+  ScheduleNotifyChangesUpdatedOnIOThread(callback);
 }
 
 void LocalFileSyncContext::AddOriginChangeObserver(
     LocalOriginChangeObserver* observer) {
   origin_change_observers_.AddObserver(observer);
 }
 
 void LocalFileSyncContext::RemoveOriginChangeObserver(
     LocalOriginChangeObserver* observer) {
   origin_change_observers_.RemoveObserver(observer);
 }
 
 base::WeakPtr<SyncableFileOperationRunner>
 LocalFileSyncContext::operation_runner() const {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   if (operation_runner_)
     return operation_runner_->AsWeakPtr();
   return base::WeakPtr<SyncableFileOperationRunner>();
 }
 
 LocalFileSyncStatus* LocalFileSyncContext::sync_status() const {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   return sync_status_.get();
 }
 
 void LocalFileSyncContext::OnSyncEnabled(const FileSystemURL& url) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   if (shutdown_on_io_)
     return;
-  UpdateChangesForOrigin(url.origin());
+  UpdateChangesForOrigin(url.origin(), NoopClosure());
   if (url_syncable_callback_.is_null() ||
       sync_status()->IsWriting(url_waiting_sync_on_io_)) {
     return;
   }
   // TODO(kinuko): may want to check how many pending tasks we have.
   ui_task_runner_->PostTask(FROM_HERE, url_syncable_callback_);
   url_syncable_callback_.Reset();
 }
 
 void LocalFileSyncContext::OnWriteEnabled(const FileSystemURL& url) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   // Nothing to do for now.
 }
 
 LocalFileSyncContext::~LocalFileSyncContext() {
 }
 
-void LocalFileSyncContext::ScheduleNotifyChangesUpdatedOnIOThread() {
+void LocalFileSyncContext::ScheduleNotifyChangesUpdatedOnIOThread(
+    const base::Closure& callback) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   if (shutdown_on_io_)
     return;
   if (base::Time::Now() > last_notified_changes_ + NotifyChangesDuration()) {
-    NotifyAvailableChangesOnIOThread();
+    NotifyAvailableChangesOnIOThread(callback);
   } else if (!timer_on_io_->IsRunning()) {
     timer_on_io_->Start(
-        FROM_HERE, NotifyChangesDuration(), this,
-        &LocalFileSyncContext::NotifyAvailableChangesOnIOThread);
+        FROM_HERE, NotifyChangesDuration(),
+        base::Bind(&LocalFileSyncContext::NotifyAvailableChangesOnIOThread,
+                   base::Unretained(this), callback));
   }
 }
 
-void LocalFileSyncContext::NotifyAvailableChangesOnIOThread() {
+void LocalFileSyncContext::NotifyAvailableChangesOnIOThread(
+    const base::Closure& callback) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   if (shutdown_on_io_)
     return;
   ui_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&LocalFileSyncContext::NotifyAvailableChanges,
-                 this, origins_with_pending_changes_));
+                 this, origins_with_pending_changes_, callback));
   last_notified_changes_ = base::Time::Now();
   origins_with_pending_changes_.clear();
 }
 
 void LocalFileSyncContext::NotifyAvailableChanges(
-    const std::set<GURL>& origins) {
+    const std::set<GURL>& origins,
+    const base::Closure& callback) {
   FOR_EACH_OBSERVER(LocalOriginChangeObserver, origin_change_observers_,
                     OnChangesAvailableInOrigins(origins));
+  callback.Run();
 }
 
 void LocalFileSyncContext::ShutdownOnIOThread() {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   shutdown_on_io_ = true;
   operation_runner_.reset();
   root_delete_helper_.reset();
   sync_status_.reset();
   timer_on_io_.reset();
 }
@@ skipping 96 matching lines @@
     return;
   }
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   backend->SetLocalFileChangeTracker(tracker_ptr->Pass());
 
   origins_with_pending_changes_.insert(origins_with_changes->begin(),
                                        origins_with_changes->end());
-  ScheduleNotifyChangesUpdatedOnIOThread();
+  ScheduleNotifyChangesUpdatedOnIOThread(NoopClosure());
 
   InitializeFileSystemContextOnIOThread(source_url, file_system_context,
                                         GURL(), std::string(),
                                         base::File::FILE_OK);
 }
 
 void LocalFileSyncContext::DidInitialize(
     const GURL& source_url,
     FileSystemContext* file_system_context,
     SyncStatusCode status) {
@@ skipping 196 matching lines @@
     return;
   sync_status()->EndSyncing(url);
 
   if (for_snapshot_sync) {
     // The caller will hold shared lock on this one.
     sync_status()->StartWriting(url);
     return;
   }
 
   // Since a sync has finished the number of changes must have been updated.
-  UpdateChangesForOrigin(url.origin());
+  UpdateChangesForOrigin(url.origin(), NoopClosure());
 }
 
 void LocalFileSyncContext::FinalizeSnapshotSyncOnIOThread(
     const FileSystemURL& url) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   if (shutdown_on_io_)
     return;
   sync_status()->EndWriting(url);
 
   // Since a sync has finished the number of changes must have been updated.
-  UpdateChangesForOrigin(url.origin());
+  UpdateChangesForOrigin(url.origin(), NoopClosure());
 }
 
 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,
@@ skipping 34 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