[SyncFS] Run RemoteToLocalSyncer as a background task

chrome/browser/sync_file_system/drive_backend/remote_to_local_syncer.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/drive_backend/remote_to_local_syncer.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
@@ skipping 88 matching lines @@
       sync_root_deletion_(false),
       weak_ptr_factory_(this) {
 }
 
 RemoteToLocalSyncer::~RemoteToLocalSyncer() {
 }
 
 void RemoteToLocalSyncer::RunPreflight(scoped_ptr<SyncTaskToken> token) {
   token->InitializeTaskLog("Remote -> Local");
 
-  scoped_ptr<TaskBlocker> task_blocker(new TaskBlocker);
-  task_blocker->exclusive = true;
-  SyncTaskManager::UpdateTaskBlocker(
-      token.Pass(), task_blocker.Pass(),
-      base::Bind(&RemoteToLocalSyncer::RunExclusive,
-                 weak_ptr_factory_.GetWeakPtr()));
-}
-
-void RemoteToLocalSyncer::RunExclusive(scoped_ptr<SyncTaskToken> token) {
   if (!drive_service() || !metadata_database() || !remote_change_processor()) {
     token->RecordLog("Context not ready.");
     SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_FAILED);
     return;
   }
 
   dirty_tracker_ = make_scoped_ptr(new FileTracker);
   if (metadata_database()->GetDirtyTracker(dirty_tracker_.get())) {
     token->RecordLog(base::StringPrintf(
         "Start: tracker_id=%" PRId64, dirty_tracker_->tracker_id()));
@@ skipping 11 matching lines @@
   remote_metadata_ = GetFileMetadata(
       metadata_database(), dirty_tracker_->file_id());
 
   if (!remote_metadata_ || !remote_metadata_->has_details()) {
     if (remote_metadata_ && !remote_metadata_->has_details()) {
       token->RecordLog(
           "Missing details of a remote file: " + remote_metadata_->file_id());
       NOTREACHED();
     }
     token->RecordLog("Missing remote metadata case.");
-    HandleMissingRemoteMetadata(token.Pass());
+
+    MoveToBackground(
+        token.Pass(),
+        base::Bind(&RemoteToLocalSyncer::HandleMissingRemoteMetadata,
+                   weak_ptr_factory_.GetWeakPtr()));
     return;
   }
 
   DCHECK(remote_metadata_);
   DCHECK(remote_metadata_->has_details());
   const FileDetails& remote_details = remote_metadata_->details();
 
   if (!dirty_tracker_->active() ||
       HasDisabledAppRoot(metadata_database(), *dirty_tracker_)) {
     // Handle inactive tracker in SyncCompleted.
@@ skipping 16 matching lines @@
 
   DCHECK(dirty_tracker_->has_synced_details());
   const FileDetails& synced_details = dirty_tracker_->synced_details();
 
   if (dirty_tracker_->tracker_id() ==
       metadata_database()->GetSyncRootTrackerID()) {
     if (remote_details.missing() ||
         synced_details.title() != remote_details.title() ||
         remote_details.parent_folder_ids_size()) {
       token->RecordLog("Sync-root deletion.");
-      HandleSyncRootDeletion(token.Pass());
+      sync_root_deletion_ = true;
+      SyncCompleted(token.Pass(), SYNC_STATUS_OK);
       return;
     }
     token->RecordLog("Trivial sync-root change.");
     SyncCompleted(token.Pass(), SYNC_STATUS_OK);
     return;
   }
 
   DCHECK_NE(dirty_tracker_->tracker_id(),
             metadata_database()->GetSyncRootTrackerID());
 
+  if (!BuildFileSystemURL(metadata_database(), *dirty_tracker_, &url_)) {
+    NOTREACHED();
+    SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
+    return;
+  }
+
+  DCHECK(url_.is_valid());
+
   if (remote_details.missing()) {
     if (!synced_details.missing()) {
       token->RecordLog("Remote file deletion.");
-      HandleDeletion(token.Pass());
+      MoveToBackground(token.Pass(),
+                       base::Bind(&RemoteToLocalSyncer::HandleDeletion,
+                                  weak_ptr_factory_.GetWeakPtr()));
       return;
     }
 
     DCHECK(synced_details.missing());
     token->RecordLog("Found a stray missing tracker: " +
                      dirty_tracker_->file_id());
     NOTREACHED();
     SyncCompleted(token.Pass(), SYNC_STATUS_OK);
     return;
   }
@@ skipping 20 matching lines @@
     NOTREACHED();
     SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
     return;
   }
   DCHECK(remote_details.file_kind() == FILE_KIND_FILE ||
          remote_details.file_kind() == FILE_KIND_FOLDER);
 
   if (synced_details.title() != remote_details.title()) {
     // Handle rename as deletion + addition.
     token->RecordLog("Detected file rename.");
-    Prepare(base::Bind(&RemoteToLocalSyncer::DidPrepareForDeletion,
-                       weak_ptr_factory_.GetWeakPtr(),
-                       base::Passed(&token)));
+
+    MoveToBackground(token.Pass(),
+                     base::Bind(&RemoteToLocalSyncer::HandleFileMove,
+                                weak_ptr_factory_.GetWeakPtr()));
     return;
   }
   DCHECK_EQ(synced_details.title(), remote_details.title());
 
   FileTracker parent_tracker;
   if (!metadata_database()->FindTrackerByTrackerID(
           dirty_tracker_->parent_tracker_id(), &parent_tracker)) {
     token->RecordLog("Missing parent tracker for a non sync-root tracker: "
                      + dirty_tracker_->file_id());
     NOTREACHED();
     SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
     return;
   }
 
   if (!HasFolderAsParent(remote_details, parent_tracker.file_id())) {
     // Handle reorganize as deletion + addition.
     token->RecordLog("Detected file reorganize.");
-    Prepare(base::Bind(&RemoteToLocalSyncer::DidPrepareForDeletion,
-                       weak_ptr_factory_.GetWeakPtr(),
-                       base::Passed(&token)));
+
+    MoveToBackground(token.Pass(),
+                     base::Bind(&RemoteToLocalSyncer::HandleFileMove,
+                                weak_ptr_factory_.GetWeakPtr()));
     return;
   }
 
   if (synced_details.file_kind() == FILE_KIND_FILE) {
     if (synced_details.md5() != remote_details.md5()) {
       token->RecordLog("Detected file content update.");
-      HandleContentUpdate(token.Pass());
+      MoveToBackground(token.Pass(),
+                       base::Bind(&RemoteToLocalSyncer::HandleContentUpdate,
+                                  weak_ptr_factory_.GetWeakPtr()));
       return;
     }
   } else {
     DCHECK_EQ(FILE_KIND_FOLDER, synced_details.file_kind());
     if (synced_details.missing()) {
       token->RecordLog("Detected folder update.");
-      HandleFolderUpdate(token.Pass());
+      MoveToBackground(token.Pass(),
+                       base::Bind(&RemoteToLocalSyncer::HandleFolderUpdate,
+                                  weak_ptr_factory_.GetWeakPtr()));
       return;
     }
     if (dirty_tracker_->needs_folder_listing()) {
       token->RecordLog("Needs listing folder.");
-      ListFolderContent(token.Pass());
+      MoveToBackground(token.Pass(),
+                       base::Bind(&RemoteToLocalSyncer::ListFolderContent,
+                                  weak_ptr_factory_.GetWeakPtr()));
       return;
     }
     SyncCompleted(token.Pass(), SYNC_STATUS_OK);
     return;
   }
 
   token->RecordLog("Trivial file change.");
   SyncCompleted(token.Pass(), SYNC_STATUS_OK);
 }
 
+void RemoteToLocalSyncer::MoveToBackground(scoped_ptr<SyncTaskToken> token,
+                                           const Continuation& continuation) {
+  DCHECK(dirty_tracker_);
+
+  scoped_ptr<TaskBlocker> blocker(new TaskBlocker);
+  blocker->app_id = dirty_tracker_->app_id();
+  if (url_.is_valid())
+    blocker->paths.push_back(url_.path());
+  blocker->file_ids.push_back(dirty_tracker_->file_id());
+  blocker->tracker_ids.push_back(dirty_tracker_->tracker_id());
+
+  SyncTaskManager::UpdateTaskBlocker(
+      token.Pass(), blocker.Pass(),
+      base::Bind(&RemoteToLocalSyncer::ContinueAsBackgroundTask,
+                 weak_ptr_factory_.GetWeakPtr(), continuation));
+}
+
+void RemoteToLocalSyncer::ContinueAsBackgroundTask(
+    const Continuation& continuation,
+    scoped_ptr<SyncTaskToken> token) {
+  DCHECK(dirty_tracker_);
+
+  // The SyncTask runs as a background task beyond this point.
+  // Not that any task can run between MoveToBackground() and
+  // ContinueAsBackgroundTask(), so we need to make sure other tasks didn't
+  // affect to the current RemoteToLocalSyncer task.
+  //
+  // - For LocalToRemoteSyncer, it may update or delete any of FileTracker and
+  //   FileMetadata. When it updates FileMetadata or FileDetails in FileTracker,
+  //   it also updates |change_id|.  So, ensure the target FileTracker and
+  //   FileMetadata exist and their |change_id|s are not updated.
+  // - For ListChangesTask, it may update FileMetadata together with |change_id|
+  //   and may delete FileTracker.
+  // - For UninstallAppTask, it may delete FileMetadata and FileTracker.
+  //   Check if FileTracker still exists.
+  // - For other RemoteToLocalSyncer, it may delete the FileTracker of parent.
+  //   Note that since RemoteToLocalSyncer demotes the target FileTracker first,
+  //   any other RemoteToLocalSyncer does not run for current |dirty_tracker_|.
+  // - Others, SyncEngineInitializer and RegisterAppTask doesn't affect to
+
+  FileTracker latest_dirty_tracker;
+  if (!metadata_database()->FindTrackerByTrackerID(
+          dirty_tracker_->tracker_id(), &latest_dirty_tracker) ||
+      dirty_tracker_->active() != latest_dirty_tracker.active() ||
+      !latest_dirty_tracker.dirty()) {
+    SyncCompleted(token.Pass(), SYNC_STATUS_RETRY);
+    return;
+  }
+
+  int64 current_change_id = kint64min;
+  int64 latest_change_id = kint64min;
+  if (dirty_tracker_->has_synced_details())
+    current_change_id = dirty_tracker_->synced_details().change_id();
+  if (latest_dirty_tracker.has_synced_details())
+    latest_change_id = latest_dirty_tracker.synced_details().change_id();
+  if (current_change_id != latest_change_id) {
+    SyncCompleted(token.Pass(), SYNC_STATUS_RETRY);
+    return;
+  }
+
+  FileMetadata latest_file_metadata;
+  if (metadata_database()->FindFileByFileID(dirty_tracker_->file_id(),
+                                            &latest_file_metadata)) {
+    if (!remote_metadata_) {
+      SyncCompleted(token.Pass(), SYNC_STATUS_RETRY);
+      return;
+    }
+
+    int64 change_id = remote_metadata_->details().change_id();
+    int64 latest_change_id = latest_file_metadata.details().change_id();
+    if (change_id != latest_change_id) {
+      SyncCompleted(token.Pass(), SYNC_STATUS_RETRY);
+      return;
+    }
+  } else {
+    if (remote_metadata_) {
+      SyncCompleted(token.Pass(), SYNC_STATUS_RETRY);
+      return;
+    }
+  }
+  continuation.Run(token.Pass());
+}
+
 void RemoteToLocalSyncer::HandleMissingRemoteMetadata(
     scoped_ptr<SyncTaskToken> token) {
   DCHECK(dirty_tracker_);
 
   drive_service()->GetFileResource(
       dirty_tracker_->file_id(),
       base::Bind(&RemoteToLocalSyncer::DidGetRemoteMetadata,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&token)));
 }
@@ skipping 134 matching lines @@
     return;
   }
 
   DCHECK_EQ(SYNC_FILE_TYPE_FILE, local_metadata_->file_type);
   sync_action_ = SYNC_ACTION_ADDED;
   // Got a remote folder for existing local file.
   // Our policy prioritize folders in this case.
   CreateFolder(token.Pass());
 }
 
-void RemoteToLocalSyncer::HandleSyncRootDeletion(
-    scoped_ptr<SyncTaskToken> token) {
-  sync_root_deletion_ = true;
-  SyncCompleted(token.Pass(), SYNC_STATUS_OK);
-}
-
 void RemoteToLocalSyncer::HandleDeletion(
     scoped_ptr<SyncTaskToken> token) {
   DCHECK(dirty_tracker_);
   DCHECK(dirty_tracker_->active());
   DCHECK(!HasDisabledAppRoot(metadata_database(), *dirty_tracker_));
   DCHECK(dirty_tracker_->has_synced_details());
   DCHECK(!dirty_tracker_->synced_details().missing());
 
   DCHECK(remote_metadata_);
   DCHECK(remote_metadata_->has_details());
   DCHECK(remote_metadata_->details().missing());
 
   Prepare(base::Bind(&RemoteToLocalSyncer::DidPrepareForDeletion,
                      weak_ptr_factory_.GetWeakPtr(),
                      base::Passed(&token)));
 }
 
+void RemoteToLocalSyncer::HandleFileMove(scoped_ptr<SyncTaskToken> token) {
+  DCHECK(dirty_tracker_);
+  DCHECK(dirty_tracker_->active());
+  DCHECK(!HasDisabledAppRoot(metadata_database(), *dirty_tracker_));
+  DCHECK(dirty_tracker_->has_synced_details());
+
+  DCHECK(remote_metadata_);
+  DCHECK(remote_metadata_->has_details());
+  DCHECK(!remote_metadata_->details().missing());
+
+  Prepare(base::Bind(&RemoteToLocalSyncer::DidPrepareForDeletion,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     base::Passed(&token)));
+}
+
 void RemoteToLocalSyncer::DidPrepareForDeletion(
     scoped_ptr<SyncTaskToken> token,
     SyncStatusCode status) {
   if (status != SYNC_STATUS_OK) {
     SyncCompleted(token.Pass(), status);
     return;
   }
 
   DCHECK(url_.is_valid());
   DCHECK(local_metadata_);
@@ skipping 152 matching lines @@
         url_, false /* clear_local_change */,
         base::Bind(SyncTaskManager::NotifyTaskDone,
                    base::Passed(&token), status));
     return;
   }
 
   SyncTaskManager::NotifyTaskDone(token.Pass(), status);
 }
 
 void RemoteToLocalSyncer::Prepare(const SyncStatusCallback& callback) {
-  bool should_success = BuildFileSystemURL(
-      metadata_database(), *dirty_tracker_, &url_);
-  DCHECK(should_success);
   DCHECK(url_.is_valid());
   remote_change_processor()->PrepareForProcessRemoteChange(
       url_,
       base::Bind(&RemoteToLocalSyncer::DidPrepare,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback));
 }
 
 void RemoteToLocalSyncer::DidPrepare(const SyncStatusCallback& callback,
                                      SyncStatusCode status,
@@ skipping 97 matching lines @@
 
 SyncStatusCallback RemoteToLocalSyncer::SyncCompletedCallback(
     scoped_ptr<SyncTaskToken> token) {
   return base::Bind(&RemoteToLocalSyncer::SyncCompleted,
                     weak_ptr_factory_.GetWeakPtr(),
                     base::Passed(&token));
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system