[SyncFS] Replace callback with token in UploadNewFile

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"
@@ skipping 205 matching lines @@
   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) {
     token->RecordLog("Detected a new file.");
-    UploadNewFile(base::Bind(
-        &LocalToRemoteSyncer::SyncCompleted,
-        weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
+    UploadNewFile(token.Pass());
     return;
   }
 
   token->RecordLog("Detected a new folder.");
   CreateRemoteFolder(token.Pass());
 }
 
 void LocalToRemoteSyncer::SyncCompleted(scoped_ptr<SyncTaskToken> token,
                                         SyncStatusCode status) {
   if (status == SYNC_STATUS_OK && target_path_ != url_.path())
@@ skipping 17 matching lines @@
   DCHECK(remote_file_tracker_->has_synced_details());
   DCHECK(remote_file_tracker_->active());
   DCHECK(remote_file_tracker_->dirty());
 
   if (local_is_missing_) {
     SyncCompleted(token.Pass(), SYNC_STATUS_OK);
     return;
   }
 
   if (local_change_.IsFile()) {
-    UploadNewFile(base::Bind(&LocalToRemoteSyncer::SyncCompleted,
-                             weak_ptr_factory_.GetWeakPtr(),
-                             base::Passed(&token)));
+    UploadNewFile(token.Pass());
     return;
   }
 
   DCHECK(local_change_.IsDirectory());
   // Check if we can reuse the remote folder.
   FileMetadata remote_file_metadata;
   if (!metadata_database()->FindFileByFileID(
           remote_file_tracker_->file_id(), &remote_file_metadata)) {
     NOTREACHED();
     CreateRemoteFolder(token.Pass());
@@ skipping 45 matching lines @@
       UploadExistingFile(token.Pass());
       return;
     }
 
     DCHECK_EQ(FILE_KIND_FOLDER, synced_details.file_kind());
     // Non-conflicting local file update to existing remote *folder*.
     // Assuming this case as local folder deletion + local file creation, delete
     // the remote folder and upload the file.
     DeleteRemoteFile(base::Bind(&LocalToRemoteSyncer::DidDeleteForUploadNewFile,
                                 weak_ptr_factory_.GetWeakPtr(),
-                                base::Bind(&LocalToRemoteSyncer::SyncCompleted,
-                                           weak_ptr_factory_.GetWeakPtr(),
-                                           base::Passed(&token))));
+                                base::Passed(&token)));
     return;
   }
 
   DCHECK(local_change_.IsDirectory());
   if (synced_details.file_kind() == FILE_KIND_FILE) {
     // Non-conflicting local folder creation to existing remote *file*.
     // Assuming this case as local file deletion + local folder creation, delete
     // the remote file and create a remote folder.
     DeleteRemoteFile(base::Bind(&LocalToRemoteSyncer::DidDeleteForCreateFolder,
                                 weak_ptr_factory_.GetWeakPtr(),
@@ skipping 196 matching lines @@
   if (!entry) {
     NOTREACHED();
     callback.Run(SYNC_STATUS_FAILED);
     return;
   }
 
   metadata_database()->UpdateByFileResource(*entry, callback);
 }
 
 void LocalToRemoteSyncer::DidDeleteForUploadNewFile(
-    const SyncStatusCallback& callback,
+    scoped_ptr<SyncTaskToken> token,
     SyncStatusCode status) {
   if (status == SYNC_STATUS_HAS_CONFLICT) {
-    UpdateRemoteMetadata(remote_file_tracker_->file_id(),
-                         base::Bind(&ReturnRetryOnSuccess, callback));
+    UpdateRemoteMetadata(
+        remote_file_tracker_->file_id(),
+        base::Bind(&ReturnRetryOnSuccess,
+                   base::Bind(&LocalToRemoteSyncer::SyncCompleted,
+                              weak_ptr_factory_.GetWeakPtr(),
+                              base::Passed(&token))));
     return;
   }
 
   if (status != SYNC_STATUS_OK) {
-    callback.Run(status);
+    SyncCompleted(token.Pass(), status);
     return;
   }
 
-  UploadNewFile(callback);
+  UploadNewFile(token.Pass());
 }
 
 void LocalToRemoteSyncer::DidDeleteForCreateFolder(
     scoped_ptr<SyncTaskToken> token,
     SyncStatusCode status) {
   if (status == SYNC_STATUS_HAS_CONFLICT) {
     UpdateRemoteMetadata(
         remote_file_tracker_->file_id(),
         base::Bind(&ReturnRetryOnSuccess,
                    base::Bind(&LocalToRemoteSyncer::SyncCompleted,
                               weak_ptr_factory_.GetWeakPtr(),
                               base::Passed(&token))));
     return;
   }
 
   if (status != SYNC_STATUS_OK) {
     SyncCompleted(token.Pass(), status);
     return;
   }
 
   CreateRemoteFolder(token.Pass());
 }
 
-void LocalToRemoteSyncer::UploadNewFile(const SyncStatusCallback& callback) {
+void LocalToRemoteSyncer::UploadNewFile(scoped_ptr<SyncTaskToken> token) {
   DCHECK(remote_parent_folder_tracker_);
 
   sync_action_ = SYNC_ACTION_ADDED;
   base::FilePath title = fileapi::VirtualPath::BaseName(target_path_);
   drive_uploader()->UploadNewFile(
       remote_parent_folder_tracker_->file_id(),
       local_path_,
       title.AsUTF8Unsafe(),
       GetMimeTypeFromTitle(title),
       drive::DriveUploader::UploadNewFileOptions(),
       base::Bind(&LocalToRemoteSyncer::DidUploadNewFile,
                  weak_ptr_factory_.GetWeakPtr(),
-                 callback),
+                 base::Passed(&token)),
       google_apis::ProgressCallback());
 }
 
 void LocalToRemoteSyncer::DidUploadNewFile(
-    const SyncStatusCallback& callback,
+    scoped_ptr<SyncTaskToken> token,
     google_apis::GDataErrorCode error,
     const GURL& upload_location,
     scoped_ptr<google_apis::FileResource> entry) {
   if (error == google_apis::HTTP_NOT_FOUND)
     needs_remote_change_listing_ = true;
 
   SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
-    callback.Run(status);
+    SyncCompleted(token.Pass(), status);
     return;
   }
 
   if (!entry) {
     NOTREACHED();
-    callback.Run(SYNC_STATUS_FAILED);
+    SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
     return;
   }
 
   metadata_database()->ReplaceActiveTrackerWithNewResource(
-      remote_parent_folder_tracker_->tracker_id(), *entry, callback);
+      remote_parent_folder_tracker_->tracker_id(), *entry,
+      base::Bind(&LocalToRemoteSyncer::SyncCompleted,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Passed(&token)));
 }
 
 void LocalToRemoteSyncer::CreateRemoteFolder(
     scoped_ptr<SyncTaskToken> token) {
   DCHECK(remote_parent_folder_tracker_);
 
   base::FilePath title = fileapi::VirtualPath::BaseName(target_path_);
   sync_action_ = SYNC_ACTION_ADDED;
 
   DCHECK(!folder_creator_);
@@ skipping 32 matching lines @@
       // The task will be finalized by the callback passed to MetadataDatabase
       // in this case.
       return;
     case MetadataDatabase::ACTIVATION_FAILED_ANOTHER_ACTIVE_TRACKER:
       // The activation failed due to another tracker that has another parent.
       // Detach the folder from the current parent to avoid using this folder as
       // active folder.
       drive_service()->RemoveResourceFromDirectory(
           remote_parent_folder_tracker_->file_id(), file_id,
           base::Bind(&LocalToRemoteSyncer::DidDetachResourceForCreationConflict,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     base::Bind(&LocalToRemoteSyncer::SyncCompleted,
-                                weak_ptr_factory_.GetWeakPtr(),
-                                base::Passed(&token))));
+                     weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
       return;
   }
 
   NOTREACHED();
   SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
   return;
 }
 
 void LocalToRemoteSyncer::DidDetachResourceForCreationConflict(
-    const SyncStatusCallback& callback,
+    scoped_ptr<SyncTaskToken> token,
     google_apis::GDataErrorCode error) {
   SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
-    callback.Run(status);
+    SyncCompleted(token.Pass(), status);
     return;
   }
 
-  callback.Run(SYNC_STATUS_RETRY);
+  SyncCompleted(token.Pass(), SYNC_STATUS_RETRY);
 }
 
 bool LocalToRemoteSyncer::IsContextReady() {
   return sync_context_->GetDriveService() &&
       sync_context_->GetDriveUploader() &&
       sync_context_->GetMetadataDatabase();
 }
 
 drive::DriveServiceInterface* LocalToRemoteSyncer::drive_service() {
   set_used_network(true);
   return sync_context_->GetDriveService();
 }
 
 drive::DriveUploaderInterface* LocalToRemoteSyncer::drive_uploader() {
   set_used_network(true);
   return sync_context_->GetDriveUploader();
 }
 
 MetadataDatabase* LocalToRemoteSyncer::metadata_database() {
   return sync_context_->GetMetadataDatabase();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system