[SyncFS] Replace SyncStatksCallbacks with SyncTaskToken in RemoteToLocalSyncer

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/file_util.h"
 #include "base/format_macros.h"
@@ skipping 131 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(SyncCompletedCallback(token.Pass()));
+    HandleMissingRemoteMetadata(token.Pass());
     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(SyncCompletedCallback(token.Pass()));
+      HandleSyncRootDeletion(token.Pass());
       return;
     }
     token->RecordLog("Trivial sync-root change.");
     SyncCompleted(token.Pass(), SYNC_STATUS_OK);
     return;
   }
 
   DCHECK_NE(dirty_tracker_->tracker_id(),
             metadata_database()->GetSyncRootTrackerID());
 
   if (remote_details.missing()) {
     if (!synced_details.missing()) {
       token->RecordLog("Remote file deletion.");
-      HandleDeletion(SyncCompletedCallback(token.Pass()));
+      HandleDeletion(token.Pass());
       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 22 matching lines @@
     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(),
-                       SyncCompletedCallback(token.Pass())));
+                       base::Passed(&token)));
     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(),
-                       SyncCompletedCallback(token.Pass())));
+                       base::Passed(&token)));
     return;
   }
 
   if (synced_details.file_kind() == FILE_KIND_FILE) {
     if (synced_details.md5() != remote_details.md5()) {
       token->RecordLog("Detected file content update.");
-      HandleContentUpdate(SyncCompletedCallback(token.Pass()));
+      HandleContentUpdate(token.Pass());
       return;
     }
   } else {
     DCHECK_EQ(FILE_KIND_FOLDER, synced_details.file_kind());
     if (synced_details.missing()) {
       token->RecordLog("Detected folder update.");
-      HandleFolderUpdate(SyncCompletedCallback(token.Pass()));
+      HandleFolderUpdate(token.Pass());
       return;
     }
     if (dirty_tracker_->needs_folder_listing()) {
       token->RecordLog("Needs listing folder.");
-      ListFolderContent(SyncCompletedCallback(token.Pass()));
+      ListFolderContent(token.Pass());
       return;
     }
     SyncCompleted(token.Pass(), SYNC_STATUS_OK);
     return;
   }
 
   token->RecordLog("Trivial file change.");
   SyncCompleted(token.Pass(), SYNC_STATUS_OK);
 }
 
 void RemoteToLocalSyncer::HandleMissingRemoteMetadata(
-    const SyncStatusCallback& callback) {
+    scoped_ptr<SyncTaskToken> token) {
   DCHECK(dirty_tracker_);
 
   drive_service()->GetFileResource(
       dirty_tracker_->file_id(),
       base::Bind(&RemoteToLocalSyncer::DidGetRemoteMetadata,
                  weak_ptr_factory_.GetWeakPtr(),
-                 callback));
+                 base::Passed(&token)));
 }
 
 void RemoteToLocalSyncer::DidGetRemoteMetadata(
-    const SyncStatusCallback& callback,
+    scoped_ptr<SyncTaskToken> token,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::FileResource> entry) {
   DCHECK(sync_context_->GetWorkerTaskRunner()->RunsTasksOnCurrentThread());
 
   SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK &&
       error != google_apis::HTTP_NOT_FOUND) {
-    callback.Run(status);
+    SyncCompleted(token.Pass(), status);
     return;
   }
 
   if (error == google_apis::HTTP_NOT_FOUND) {
     metadata_database()->UpdateByDeletedRemoteFile(
-        dirty_tracker_->file_id(), callback);
+        dirty_tracker_->file_id(), SyncCompletedCallback(token.Pass()));
     return;
   }
 
   if (!entry) {
     NOTREACHED();
-    callback.Run(SYNC_STATUS_FAILED);
+    SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
     return;
   }
 
   metadata_database()->UpdateByFileResource(
       *entry,
       base::Bind(&RemoteToLocalSyncer::DidUpdateDatabaseForRemoteMetadata,
-                 weak_ptr_factory_.GetWeakPtr(), callback));
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Passed(&token)));
 }
 
 void RemoteToLocalSyncer::DidUpdateDatabaseForRemoteMetadata(
-    const SyncStatusCallback& callback,
+    scoped_ptr<SyncTaskToken> token,
     SyncStatusCode status) {
   if (status != SYNC_STATUS_OK) {
-    callback.Run(status);
+    SyncCompleted(token.Pass(), status);
     return;
   }
 
-  callback.Run(SYNC_STATUS_RETRY);  // Do not update |dirty_tracker_|.
+  // Do not update |dirty_tracker_|.
+  SyncCompleted(token.Pass(), SYNC_STATUS_RETRY);
 }
 
 void RemoteToLocalSyncer::DidPrepareForAddOrUpdateFile(
-    const SyncStatusCallback& callback,
+    scoped_ptr<SyncTaskToken> token,
     SyncStatusCode status) {
   if (status != SYNC_STATUS_OK) {
-    callback.Run(status);
+    SyncCompleted(token.Pass(), status);
     return;
   }
 
   DCHECK(url_.is_valid());
   DCHECK(local_metadata_);
   DCHECK(local_changes_);
 
   // Check if the local file exists.
   if (local_metadata_->file_type == SYNC_FILE_TYPE_UNKNOWN ||
       (!local_changes_->empty() && local_changes_->back().IsDelete())) {
     sync_action_ = SYNC_ACTION_ADDED;
     // Missing local file case.
     // Download the file and add it to local as a new file.
-    DownloadFile(callback);
+    DownloadFile(token.Pass());
     return;
   }
 
   DCHECK(local_changes_->empty() || local_changes_->back().IsAddOrUpdate());
   if (local_changes_->empty()) {
     if (local_metadata_->file_type == SYNC_FILE_TYPE_FILE) {
       sync_action_ = SYNC_ACTION_UPDATED;
       // Download the file and overwrite the existing local file.
-      DownloadFile(callback);
+      DownloadFile(token.Pass());
       return;
     }
 
     DCHECK_EQ(SYNC_FILE_TYPE_DIRECTORY, local_metadata_->file_type);
 
     // Got a remote regular file modification for existing local folder.
     // Our policy prioritize folders in this case.
     // Lower the priority of the tracker to prevent repeated remote sync to the
     // same tracker, and let local-to-remote sync phase process this change.
     metadata_database()->LowerTrackerPriority(dirty_tracker_->tracker_id());
     remote_change_processor()->RecordFakeLocalChange(
         url_,
         FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
                    local_metadata_->file_type),
-        callback);
+        SyncCompletedCallback(token.Pass()));
     return;
   }
 
   DCHECK(local_changes_->back().IsAddOrUpdate());
   // Conflict case.
   // Do nothing for the change now, and handle this in LocalToRemoteSync phase.
 
   // Lower the priority of the tracker to prevent repeated remote sync to the
   // same tracker.
   metadata_database()->LowerTrackerPriority(dirty_tracker_->tracker_id());
-  callback.Run(SYNC_STATUS_RETRY);
+  SyncCompleted(token.Pass(), SYNC_STATUS_RETRY);
 }
 
 void RemoteToLocalSyncer::HandleFolderUpdate(
-    const SyncStatusCallback& callback) {
+    scoped_ptr<SyncTaskToken> token) {
   DCHECK(dirty_tracker_);
   DCHECK(dirty_tracker_->active());
   DCHECK(!HasDisabledAppRoot(metadata_database(), *dirty_tracker_));
 
   DCHECK(remote_metadata_);
   DCHECK(remote_metadata_->has_details());
   DCHECK(!remote_metadata_->details().missing());
   DCHECK_EQ(FILE_KIND_FOLDER, remote_metadata_->details().file_kind());
 
   Prepare(base::Bind(&RemoteToLocalSyncer::DidPrepareForFolderUpdate,
-                     weak_ptr_factory_.GetWeakPtr(), callback));
+                     weak_ptr_factory_.GetWeakPtr(),
+                     base::Passed(&token)));
 }
 
 void RemoteToLocalSyncer::DidPrepareForFolderUpdate(
-    const SyncStatusCallback& callback,
+    scoped_ptr<SyncTaskToken> token,
     SyncStatusCode status) {
   if (status != SYNC_STATUS_OK) {
-    callback.Run(status);
+    SyncCompleted(token.Pass(), status);
     return;
   }
 
   DCHECK(url_.is_valid());
   DCHECK(local_metadata_);
   DCHECK(local_changes_);
 
   // Check if the local file exists.
   if (local_metadata_->file_type == SYNC_FILE_TYPE_UNKNOWN ||
       (!local_changes_->empty() && local_changes_->back().IsDelete())) {
     sync_action_ = SYNC_ACTION_ADDED;
     // No local file exists at the path.
-    CreateFolder(callback);
+    CreateFolder(token.Pass());
     return;
   }
 
   if (local_metadata_->file_type == SYNC_FILE_TYPE_DIRECTORY) {
     // There already exists a folder, nothing left to do.
     if (dirty_tracker_->needs_folder_listing() &&
         !dirty_tracker_->synced_details().missing()) {
-      ListFolderContent(callback);
+      ListFolderContent(token.Pass());
     } else {
-      callback.Run(SYNC_STATUS_OK);
+      SyncCompleted(token.Pass(), SYNC_STATUS_OK);
     }
     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(callback);
+  CreateFolder(token.Pass());
 }
 
 void RemoteToLocalSyncer::HandleSyncRootDeletion(
-    const SyncStatusCallback& callback) {
+    scoped_ptr<SyncTaskToken> token) {
   sync_root_deletion_ = true;
-  callback.Run(SYNC_STATUS_OK);
+  SyncCompleted(token.Pass(), SYNC_STATUS_OK);
 }
 
 void RemoteToLocalSyncer::HandleDeletion(
-    const SyncStatusCallback& callback) {
+    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(), callback));
+                     weak_ptr_factory_.GetWeakPtr(),
+                     base::Passed(&token)));
 }
 
 void RemoteToLocalSyncer::DidPrepareForDeletion(
-    const SyncStatusCallback& callback,
+    scoped_ptr<SyncTaskToken> token,
     SyncStatusCode status) {
   if (status != SYNC_STATUS_OK) {
-    callback.Run(status);
+    SyncCompleted(token.Pass(), status);
     return;
   }
 
   DCHECK(url_.is_valid());
   DCHECK(local_metadata_);
   DCHECK(local_changes_);
 
   // Check if the local file exists.
   if (local_metadata_->file_type == SYNC_FILE_TYPE_UNKNOWN ||
       (!local_changes_->empty() && local_changes_->back().IsDelete())) {
     // No local file exists at the path.
-    callback.Run(SYNC_STATUS_OK);
+    SyncCompleted(token.Pass(), SYNC_STATUS_OK);
     return;
   }
 
   DCHECK(local_changes_->empty() || local_changes_->back().IsAddOrUpdate());
   if (local_changes_->empty()) {
     sync_action_ = SYNC_ACTION_DELETED;
-    DeleteLocalFile(callback);
+    DeleteLocalFile(token.Pass());
     return;
   }
 
   DCHECK(local_changes_->back().IsAddOrUpdate());
   // File is remotely deleted and locally updated.
   // Ignore the remote deletion and handle it as if applied successfully.
-  callback.Run(SYNC_STATUS_OK);
+  SyncCompleted(token.Pass(), SYNC_STATUS_OK);
 }
 
 void RemoteToLocalSyncer::HandleContentUpdate(
-    const SyncStatusCallback& callback) {
+    scoped_ptr<SyncTaskToken> token) {
   DCHECK(dirty_tracker_);
   DCHECK(dirty_tracker_->active());
   DCHECK(!HasDisabledAppRoot(metadata_database(), *dirty_tracker_));
   DCHECK(dirty_tracker_->has_synced_details());
   DCHECK_EQ(FILE_KIND_FILE, dirty_tracker_->synced_details().file_kind());
 
   DCHECK(remote_metadata_);
   DCHECK(remote_metadata_->has_details());
   DCHECK(!remote_metadata_->details().missing());
 
   DCHECK_NE(dirty_tracker_->synced_details().md5(),
             remote_metadata_->details().md5());
 
   Prepare(base::Bind(&RemoteToLocalSyncer::DidPrepareForAddOrUpdateFile,
-                     weak_ptr_factory_.GetWeakPtr(), callback));
+                     weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
 }
 
 void RemoteToLocalSyncer::ListFolderContent(
-    const SyncStatusCallback& callback) {
+    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_EQ(FILE_KIND_FOLDER, dirty_tracker_->synced_details().file_kind());
   DCHECK(dirty_tracker_->needs_folder_listing());
 
   DCHECK(remote_metadata_);
   DCHECK(remote_metadata_->has_details());
   DCHECK(!remote_metadata_->details().missing());
 
   // TODO(tzik): Replace this call with ChildList version.
   drive_service()->GetFileListInDirectory(
       dirty_tracker_->file_id(),
       base::Bind(&RemoteToLocalSyncer::DidListFolderContent,
                  weak_ptr_factory_.GetWeakPtr(),
-                 callback,
+                 base::Passed(&token),
                  base::Passed(make_scoped_ptr(new FileIDList))));
 }
 
 void RemoteToLocalSyncer::DidListFolderContent(
-    const SyncStatusCallback& callback,
+    scoped_ptr<SyncTaskToken> token,
     scoped_ptr<FileIDList> children,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::FileList> file_list) {
   SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
-    callback.Run(status);
+    SyncCompleted(token.Pass(), status);
     return;
   }
 
   if (!file_list) {
     NOTREACHED();
-    callback.Run(SYNC_STATUS_FAILED);
+    SyncCompleted(token.Pass(), SYNC_STATUS_FAILED);
     return;
   }
 
   children->reserve(children->size() + file_list->items().size());
   for (ScopedVector<google_apis::FileResource>::const_iterator itr =
            file_list->items().begin();
        itr != file_list->items().end();
        ++itr) {
     children->push_back((*itr)->file_id());
   }
 
   if (!file_list->next_link().is_empty()) {
     drive_service()->GetRemainingFileList(
         file_list->next_link(),
         base::Bind(&RemoteToLocalSyncer::DidListFolderContent,
                    weak_ptr_factory_.GetWeakPtr(),
-                   callback, base::Passed(&children)));
+                   base::Passed(&token), base::Passed(&children)));
     return;
   }
 
   metadata_database()->PopulateFolderByChildList(
-      dirty_tracker_->file_id(), *children, callback);
+      dirty_tracker_->file_id(), *children,
+      SyncCompletedCallback(token.Pass()));
 }
 
 void RemoteToLocalSyncer::SyncCompleted(scoped_ptr<SyncTaskToken> token,
                                         SyncStatusCode status) {
   token->RecordLog(base::StringPrintf(
       "[Remote -> Local]: Finished: action=%s, tracker=%" PRId64 " status=%s",
       SyncActionToString(sync_action_), dirty_tracker_->tracker_id(),
       SyncStatusCodeToString(status)));
 
   if (sync_root_deletion_) {
@@ skipping 69 matching lines @@
     return;
   }
   prepared_ = true;
 
   local_metadata_.reset(new SyncFileMetadata(local_metadata));
   local_changes_.reset(new FileChangeList(local_changes));
 
   callback.Run(status);
 }
 
-void RemoteToLocalSyncer::DeleteLocalFile(const SyncStatusCallback& callback) {
+void RemoteToLocalSyncer::DeleteLocalFile(scoped_ptr<SyncTaskToken> token) {
   remote_change_processor()->ApplyRemoteChange(
       FileChange(FileChange::FILE_CHANGE_DELETE, SYNC_FILE_TYPE_UNKNOWN),
       base::FilePath(),
       url_,
-      callback);
+      SyncCompletedCallback(token.Pass()));
 }
 
-void RemoteToLocalSyncer::DownloadFile(const SyncStatusCallback& callback) {
+void RemoteToLocalSyncer::DownloadFile(scoped_ptr<SyncTaskToken> token) {
   DCHECK(sync_context_->GetWorkerTaskRunner()->RunsTasksOnCurrentThread());
 
   webkit_blob::ScopedFile file = CreateTemporaryFile(
       make_scoped_refptr(sync_context_->GetWorkerTaskRunner()));
 
   base::FilePath path = file.path();
   drive_service()->DownloadFile(
       path, remote_metadata_->file_id(),
       base::Bind(&RemoteToLocalSyncer::DidDownloadFile,
                  weak_ptr_factory_.GetWeakPtr(),
-                 callback, base::Passed(&file)),
+                 base::Passed(&token), base::Passed(&file)),
       google_apis::GetContentCallback(),
       google_apis::ProgressCallback());
 }
 
-void RemoteToLocalSyncer::DidDownloadFile(const SyncStatusCallback& callback,
+void RemoteToLocalSyncer::DidDownloadFile(scoped_ptr<SyncTaskToken> token,
                                           webkit_blob::ScopedFile file,
                                           google_apis::GDataErrorCode error,
                                           const base::FilePath&) {
   DCHECK(sync_context_->GetWorkerTaskRunner()->RunsTasksOnCurrentThread());
 
   SyncStatusCode status = GDataErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
-    callback.Run(status);
+    SyncCompleted(token.Pass(), status);
     return;
   }
 
   base::FilePath path = file.path();
   const std::string md5 = drive::util::GetMd5Digest(path);
   if (md5.empty()) {
-    callback.Run(SYNC_FILE_ERROR_NOT_FOUND);
+    SyncCompleted(token.Pass(), SYNC_FILE_ERROR_NOT_FOUND);
     return;
   }
 
   if (md5 != remote_metadata_->details().md5()) {
     // File has been modified since last metadata retrieval.
 
     // Lower the priority of the tracker to prevent repeated remote sync to the
     // same tracker.
     metadata_database()->LowerTrackerPriority(dirty_tracker_->tracker_id());
-    callback.Run(SYNC_STATUS_RETRY);
+    SyncCompleted(token.Pass(), SYNC_STATUS_RETRY);
     return;
   }
 
   remote_change_processor()->ApplyRemoteChange(
       FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE, SYNC_FILE_TYPE_FILE),
       path, url_,
       base::Bind(&RemoteToLocalSyncer::DidApplyDownload,
                  weak_ptr_factory_.GetWeakPtr(),
-                 callback, base::Passed(&file)));
+                 base::Passed(&token), base::Passed(&file)));
 }
 
-void RemoteToLocalSyncer::DidApplyDownload(const SyncStatusCallback& callback,
+void RemoteToLocalSyncer::DidApplyDownload(scoped_ptr<SyncTaskToken> token,
                                            webkit_blob::ScopedFile,
                                            SyncStatusCode status) {
   if (status != SYNC_STATUS_OK)
     metadata_database()->LowerTrackerPriority(dirty_tracker_->tracker_id());
-  callback.Run(status);
+  SyncCompleted(token.Pass(), status);
 }
 
-void RemoteToLocalSyncer::CreateFolder(const SyncStatusCallback& callback) {
+void RemoteToLocalSyncer::CreateFolder(scoped_ptr<SyncTaskToken> token) {
   remote_change_processor()->ApplyRemoteChange(
       FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
                  SYNC_FILE_TYPE_DIRECTORY),
       base::FilePath(), url_,
-      callback);
+      SyncCompletedCallback(token.Pass()));
 }
 
 drive::DriveServiceInterface* RemoteToLocalSyncer::drive_service() {
   return sync_context_->GetDriveService();
 }
 
 MetadataDatabase* RemoteToLocalSyncer::metadata_database() {
   return sync_context_->GetMetadataDatabase();
 }
 
 RemoteChangeProcessor* RemoteToLocalSyncer::remote_change_processor() {
   DCHECK(sync_context_->GetRemoteChangeProcessor());
   return sync_context_->GetRemoteChangeProcessor();
 }
 
 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