[SyncFS] Run LocalToRemoteSyncer as SyncTask

chrome/browser/sync_file_system/drive_backend/local_to_remote_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/local_to_remote_syncer.h"
 
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/sequenced_task_runner.h"
 #include "base/task_runner_util.h"
 #include "chrome/browser/drive/drive_api_util.h"
 #include "chrome/browser/drive/drive_service_interface.h"
 #include "chrome/browser/drive/drive_uploader.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/folder_creator.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.pb.h"
 #include "chrome/browser/sync_file_system/drive_backend/sync_engine_context.h"
+#include "chrome/browser/sync_file_system/drive_backend/sync_task_manager.h"
+#include "chrome/browser/sync_file_system/drive_backend/sync_task_token.h"
 #include "chrome/browser/sync_file_system/logger.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 namespace sync_file_system {
 namespace drive_backend {
 
 namespace {
 
 scoped_ptr<FileTracker> FindTrackerByID(MetadataDatabase* metadata_database,
@@ skipping 33 matching lines @@
       needs_remote_change_listing_(false),
       weak_ptr_factory_(this) {
   DCHECK(local_is_missing_ ||
          local_change.file_type() == local_metadata.file_type)
       << local_change.DebugString() << " metadata:" << local_metadata.file_type;
 }
 
 LocalToRemoteSyncer::~LocalToRemoteSyncer() {
 }
 
-void LocalToRemoteSyncer::RunExclusive(const SyncStatusCallback& callback) {
+void LocalToRemoteSyncer::RunPreflight(scoped_ptr<SyncTaskToken> token) {
+  scoped_ptr<BlockingFactor> blocking_factor(new BlockingFactor);
+  blocking_factor->exclusive = true;
+  SyncTaskManager::UpdateBlockingFactor(
+      token.Pass(), blocking_factor.Pass(),
+      base::Bind(&LocalToRemoteSyncer::RunExclusive,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+void LocalToRemoteSyncer::RunExclusive(scoped_ptr<SyncTaskToken> token) {
   if (!IsContextReady()) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Local -> Remote] Context not ready.");
     NOTREACHED();
-    callback.Run(SYNC_STATUS_FAILED);
+    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_FAILED);
     return;
   }
 
-  SyncStatusCallback wrapped_callback = base::Bind(
-      &LocalToRemoteSyncer::SyncCompleted, weak_ptr_factory_.GetWeakPtr(),
-      callback);
-
   util::Log(logging::LOG_VERBOSE, FROM_HERE,
             "[Local -> Remote] Start: %s on %s@%s %s",
             local_change_.DebugString().c_str(),
             url_.path().AsUTF8Unsafe().c_str(),
             url_.origin().host().c_str(),
             local_is_missing_ ? "(missing)" : "");
 
   if (local_is_missing_ && !local_change_.IsDelete()) {
     // Stray file, we can just return.
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Local -> Remote]: Missing file for non-delete change");
-    callback.Run(SYNC_STATUS_OK);
+    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_OK);
     return;
   }
 
   std::string app_id = url_.origin().host();
   base::FilePath path = url_.path();
 
   scoped_ptr<FileTracker> active_ancestor_tracker(new FileTracker);
   base::FilePath active_ancestor_path;
   if (!metadata_database()->FindNearestActiveAncestor(
           app_id, path,
           active_ancestor_tracker.get(), &active_ancestor_path)) {
     // The app is disabled or not registered.
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Local -> Remote]: App is disabled or not registered");
-    callback.Run(SYNC_STATUS_UNKNOWN_ORIGIN);
+    SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_UNKNOWN_ORIGIN);
     return;
   }
   DCHECK(active_ancestor_tracker->active());
   DCHECK(active_ancestor_tracker->has_synced_details());
   const FileDetails& active_ancestor_details =
       active_ancestor_tracker->synced_details();
 
   // TODO(tzik): Consider handling
   // active_ancestor_tracker->synced_details().missing() case.
 
   DCHECK(active_ancestor_details.file_kind() == FILE_KIND_FILE ||
          active_ancestor_details.file_kind() == FILE_KIND_FOLDER);
 
   base::FilePath missing_entries;
   if (active_ancestor_path.empty()) {
     missing_entries = path;
   } else if (active_ancestor_path != path) {
-    bool should_success = active_ancestor_path.AppendRelativePath(
-        path, &missing_entries);
-    if (!should_success) {
+    if (!active_ancestor_path.AppendRelativePath(path, &missing_entries)) {
       NOTREACHED() << "[Local -> Remote]: Detected invalid ancestor: "
                    << active_ancestor_path.value();
-      callback.Run(SYNC_STATUS_FAILED);
+      SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_FAILED);
       return;
     }
   }
 
   std::vector<base::FilePath::StringType> missing_components;
   fileapi::VirtualPath::GetComponents(missing_entries, &missing_components);
 
   if (!missing_components.empty()) {
     if (local_is_missing_) {
       util::Log(logging::LOG_VERBOSE, FROM_HERE,
                 "[Local -> Remote]: Both local and remote are marked missing");
       // !IsDelete() but SYNC_FILE_TYPE_UNKNOWN could happen when a file is
       // deleted by recursive deletion (which is not recorded by tracker)
       // but there're remaining changes for the same file in the tracker.
 
       // Local file is deleted and remote file is missing, already deleted or
       // not yet synced.  There is nothing to do for the file.
-      callback.Run(SYNC_STATUS_OK);
+      SyncTaskManager::NotifyTaskDone(token.Pass(), SYNC_STATUS_OK);
       return;
     }
   }
 
+  SyncStatusCallback callback = base::Bind(
+      &LocalToRemoteSyncer::SyncCompleted, weak_ptr_factory_.GetWeakPtr(),
+      base::Passed(&token));
+
   if (missing_components.size() > 1) {
     // The original target doesn't have remote file and parent.
     // Try creating the parent first.
     if (active_ancestor_details.file_kind() == FILE_KIND_FOLDER) {
       remote_parent_folder_tracker_ = active_ancestor_tracker.Pass();
       target_path_ = active_ancestor_path.Append(missing_components[0]);
       util::Log(logging::LOG_VERBOSE, FROM_HERE,
                 "[Local -> Remote]: Detected missing parent folder.");
-      CreateRemoteFolder(wrapped_callback);
+      CreateRemoteFolder(callback);
       return;
     }
 
     DCHECK(active_ancestor_details.file_kind() == FILE_KIND_FILE);
     remote_parent_folder_tracker_ =
         FindTrackerByID(metadata_database(),
                         active_ancestor_tracker->parent_tracker_id());
     remote_file_tracker_ = active_ancestor_tracker.Pass();
     target_path_ = active_ancestor_path;
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Local -> Remote]: Detected non-folder file in its path.");
     DeleteRemoteFile(base::Bind(&LocalToRemoteSyncer::DidDeleteForCreateFolder,
                                 weak_ptr_factory_.GetWeakPtr(),
-                                wrapped_callback));
-
+                                callback));
     return;
   }
 
   if (missing_components.empty()) {
     // The original target has remote active file/folder.
     remote_parent_folder_tracker_ =
         FindTrackerByID(metadata_database(),
                         active_ancestor_tracker->parent_tracker_id());
     remote_file_tracker_ = active_ancestor_tracker.Pass();
     target_path_ = url_.path();
     DCHECK(target_path_ == active_ancestor_path);
 
     if (remote_file_tracker_->dirty()) {
       util::Log(logging::LOG_VERBOSE, FROM_HERE,
                 "[Local -> Remote]: Detected conflicting dirty tracker:%"
                 PRId64, remote_file_tracker_->tracker_id());
       // Both local and remote file has pending modification.
-      HandleConflict(wrapped_callback);
+      HandleConflict(callback);
       return;
     }
 
     // Non-conflicting file/folder update case.
-    HandleExistingRemoteFile(wrapped_callback);
+    HandleExistingRemoteFile(callback);
     return;
   }
 
   DCHECK(local_change_.IsAddOrUpdate());
   DCHECK_EQ(1u, missing_components.size());
   // The original target has remote parent folder and doesn't have remote active
   // file.
   // Upload the file as a new file or create a folder.
   remote_parent_folder_tracker_ = active_ancestor_tracker.Pass();
   target_path_ = url_.path();
   DCHECK(target_path_ == active_ancestor_path.Append(missing_components[0]));
   if (local_change_.file_type() == SYNC_FILE_TYPE_FILE) {
     util::Log(logging::LOG_VERBOSE, FROM_HERE,
               "[Local -> Remote]: Detected a new file.");
-    UploadNewFile(wrapped_callback);
+    UploadNewFile(callback);
     return;
   }
   util::Log(logging::LOG_VERBOSE, FROM_HERE,
             "[Local -> Remote]: Detected a new folder.");
-  CreateRemoteFolder(wrapped_callback);
+  CreateRemoteFolder(callback);
 }
 
-void LocalToRemoteSyncer::SyncCompleted(const SyncStatusCallback& callback,
+void LocalToRemoteSyncer::SyncCompleted(scoped_ptr<SyncTaskToken> token,
                                         SyncStatusCode status) {
   if (status == SYNC_STATUS_OK && target_path_ != url_.path())
     status = SYNC_STATUS_RETRY;
 
   if (needs_remote_change_listing_)
     status = SYNC_STATUS_FILE_BUSY;
 
   util::Log(logging::LOG_VERBOSE, FROM_HERE,
             "[Local -> Remote]: Finished: action=%s, status=%s for %s@%s",
             SyncActionToString(sync_action_),
             SyncStatusCodeToString(status),
             target_path_.AsUTF8Unsafe().c_str(),
             url_.origin().host().c_str());
 
-  callback.Run(status);
+  SyncTaskManager::NotifyTaskDone(token.Pass(), status);
 }
 
 void LocalToRemoteSyncer::HandleConflict(const SyncStatusCallback& callback) {
   DCHECK(remote_file_tracker_);
   DCHECK(remote_file_tracker_->has_synced_details());
   DCHECK(remote_file_tracker_->active());
   DCHECK(remote_file_tracker_->dirty());
 
   if (local_is_missing_) {
     callback.Run(SYNC_STATUS_OK);
     return;
   }
 
   if (local_change_.IsFile()) {
     UploadNewFile(callback);
     return;
   }
 
   DCHECK(local_change_.IsDirectory());
   // Check if we can reuse the remote folder.
   FileMetadata remote_file_metadata;
-  bool should_success = metadata_database()->FindFileByFileID(
-      remote_file_tracker_->file_id(), &remote_file_metadata);
-  if (!should_success) {
+  if (!metadata_database()->FindFileByFileID(
+          remote_file_tracker_->file_id(), &remote_file_metadata)) {
     NOTREACHED();
     CreateRemoteFolder(callback);
     return;
   }
 
   const FileDetails& remote_details = remote_file_metadata.details();
   base::FilePath title = fileapi::VirtualPath::BaseName(target_path_);
   if (!remote_details.missing() &&
       remote_details.file_kind() == FILE_KIND_FOLDER &&
       remote_details.title() == title.AsUTF8Unsafe() &&
@@ skipping 175 matching lines @@
 
 void LocalToRemoteSyncer::DidUpdateDatabaseForUploadExistingFile(
     const SyncStatusCallback& callback,
     SyncStatusCode status) {
   if (status != SYNC_STATUS_OK) {
     callback.Run(status);
     return;
   }
 
   FileMetadata file;
-  bool should_success = metadata_database()->FindFileByFileID(
-      remote_file_tracker_->file_id(), &file);
-  if (!should_success) {
+  if (!metadata_database()->FindFileByFileID(
+          remote_file_tracker_->file_id(), &file)) {
     NOTREACHED();
     callback.Run(SYNC_STATUS_FAILED);
     return;
   }
 
   const FileDetails& details = file.details();
   base::FilePath title = fileapi::VirtualPath::BaseName(target_path_);
   if (!details.missing() &&
       details.file_kind() == FILE_KIND_FILE &&
       details.title() == title.AsUTF8Unsafe() &&
@@ skipping 206 matching lines @@
   set_used_network(true);
   return sync_context_->GetDriveUploader();
 }
 
 MetadataDatabase* LocalToRemoteSyncer::metadata_database() {
   return sync_context_->GetMetadataDatabase();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system