Convert //chrome/browser/sync_file_system from scoped_ptr to std::unique_ptr

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 <stdint.h>
+
 #include <limits>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/callback_helper.h"
 #include "chrome/browser/sync_file_system/drive_backend/drive_backend_util.h"
 #include "chrome/browser/sync_file_system/drive_backend/metadata_database.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/drive_backend/task_dependency_manager.h"
 #include "chrome/browser/sync_file_system/logger.h"
@@ skipping 38 matching lines @@
   DCHECK(tracker.active());
   FileTracker app_root_tracker;
   if (database->FindAppRootTracker(tracker.app_id(), &app_root_tracker)) {
     DCHECK(app_root_tracker.tracker_kind() == TRACKER_KIND_APP_ROOT ||
            app_root_tracker.tracker_kind() == TRACKER_KIND_DISABLED_APP_ROOT);
     return app_root_tracker.tracker_kind() == TRACKER_KIND_DISABLED_APP_ROOT;
   }
   return false;
 }
 
-scoped_ptr<FileMetadata> GetFileMetadata(MetadataDatabase* database,
-                                         const std::string& file_id) {
-  scoped_ptr<FileMetadata> metadata(new FileMetadata);
+std::unique_ptr<FileMetadata> GetFileMetadata(MetadataDatabase* database,
+                                              const std::string& file_id) {
+  std::unique_ptr<FileMetadata> metadata(new FileMetadata);
   if (!database->FindFileByFileID(file_id, metadata.get()))
     metadata.reset();
   return metadata;
 }
 
 // Creates a temporary file in |dir_path|.  This must be called on an
 // IO-allowed task runner, and the runner must be given as |file_task_runner|.
 storage::ScopedFile CreateTemporaryFile(
     const scoped_refptr<base::TaskRunner>& file_task_runner) {
   base::FilePath temp_file_path;
@@ skipping 12 matching lines @@
       file_type_(SYNC_FILE_TYPE_UNKNOWN),
       sync_action_(SYNC_ACTION_NONE),
       prepared_(false),
       sync_root_deletion_(false),
       weak_ptr_factory_(this) {
 }
 
 RemoteToLocalSyncer::~RemoteToLocalSyncer() {
 }
 
-void RemoteToLocalSyncer::RunPreflight(scoped_ptr<SyncTaskToken> token) {
+void RemoteToLocalSyncer::RunPreflight(std::unique_ptr<SyncTaskToken> token) {
   token->InitializeTaskLog("Remote -> Local");
 
   if (!drive_service() || !metadata_database() || !remote_change_processor()) {
     token->RecordLog("Context not ready.");
     SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
 
-  dirty_tracker_ = make_scoped_ptr(new FileTracker);
+  dirty_tracker_ = base::WrapUnique(new FileTracker);
   if (metadata_database()->GetDirtyTracker(dirty_tracker_.get())) {
     token->RecordLog(base::StringPrintf(
         "Start: tracker_id=%" PRId64, dirty_tracker_->tracker_id()));
     metadata_database()->DemoteTracker(dirty_tracker_->tracker_id());
     ResolveRemoteChange(std::move(token));
     return;
   }
 
   token->RecordLog("Nothing to do.");
   SyncTaskManager::NotifyTaskDone(std::move(token),
                                   SYNC_STATUS_NO_CHANGE_TO_SYNC);
 }
 
-void RemoteToLocalSyncer::ResolveRemoteChange(scoped_ptr<SyncTaskToken> token) {
+void RemoteToLocalSyncer::ResolveRemoteChange(
+    std::unique_ptr<SyncTaskToken> token) {
   DCHECK(dirty_tracker_);
   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();
     }
@@ skipping 158 matching lines @@
       return;
     }
     SyncCompleted(std::move(token), SYNC_STATUS_OK);
     return;
   }
 
   token->RecordLog("Trivial file change.");
   SyncCompleted(std::move(token), SYNC_STATUS_OK);
 }
 
-void RemoteToLocalSyncer::MoveToBackground(scoped_ptr<SyncTaskToken> token,
+void RemoteToLocalSyncer::MoveToBackground(std::unique_ptr<SyncTaskToken> token,
                                            const Continuation& continuation) {
   DCHECK(dirty_tracker_);
 
-  scoped_ptr<TaskBlocker> blocker(new TaskBlocker);
+  std::unique_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(
       std::move(token), std::move(blocker),
       base::Bind(&RemoteToLocalSyncer::ContinueAsBackgroundTask,
                  weak_ptr_factory_.GetWeakPtr(), continuation));
 }
 
 void RemoteToLocalSyncer::ContinueAsBackgroundTask(
     const Continuation& continuation,
-    scoped_ptr<SyncTaskToken> token) {
+    std::unique_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
@@ skipping 44 matching lines @@
   } else {
     if (remote_metadata_) {
       SyncCompleted(std::move(token), SYNC_STATUS_RETRY);
       return;
     }
   }
   continuation.Run(std::move(token));
 }
 
 void RemoteToLocalSyncer::HandleMissingRemoteMetadata(
-    scoped_ptr<SyncTaskToken> token) {
+    std::unique_ptr<SyncTaskToken> token) {
   DCHECK(dirty_tracker_);
 
   drive_service()->GetFileResource(
       dirty_tracker_->file_id(),
       base::Bind(&RemoteToLocalSyncer::DidGetRemoteMetadata,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&token)));
 }
 
 void RemoteToLocalSyncer::DidGetRemoteMetadata(
-    scoped_ptr<SyncTaskToken> token,
+    std::unique_ptr<SyncTaskToken> token,
     google_apis::DriveApiErrorCode error,
-    scoped_ptr<google_apis::FileResource> entry) {
+    std::unique_ptr<google_apis::FileResource> entry) {
   DCHECK(sync_context_->GetWorkerTaskRunner()->RunsTasksOnCurrentThread());
 
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK &&
       error != google_apis::HTTP_NOT_FOUND) {
     SyncCompleted(std::move(token), status);
     return;
   }
 
   if (error == google_apis::HTTP_NOT_FOUND) {
@@ skipping 15 matching lines @@
     return;
   }
 
   metadata_database()->PromoteDemotedTracker(dirty_tracker_->tracker_id());
 
   // Do not update |dirty_tracker_|.
   SyncCompleted(std::move(token), SYNC_STATUS_RETRY);
 }
 
 void RemoteToLocalSyncer::DidPrepareForAddOrUpdateFile(
-    scoped_ptr<SyncTaskToken> token,
+    std::unique_ptr<SyncTaskToken> token,
     SyncStatusCode status) {
   if (status != SYNC_STATUS_OK) {
     SyncCompleted(std::move(token), status);
     return;
   }
 
   DCHECK(url_.is_valid());
   DCHECK(local_metadata_);
   DCHECK(local_changes_);
 
@@ skipping 30 matching lines @@
     return;
   }
 
   DCHECK(local_changes_->back().IsAddOrUpdate());
   // Conflict case.
   // Do nothing for the change now, and handle this in LocalToRemoteSync phase.
   SyncCompleted(std::move(token), SYNC_STATUS_RETRY);
 }
 
 void RemoteToLocalSyncer::HandleFolderUpdate(
-    scoped_ptr<SyncTaskToken> token) {
+    std::unique_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(),
                      base::Passed(&token)));
 }
 
 void RemoteToLocalSyncer::DidPrepareForFolderUpdate(
-    scoped_ptr<SyncTaskToken> token,
+    std::unique_ptr<SyncTaskToken> token,
     SyncStatusCode status) {
   if (status != SYNC_STATUS_OK) {
     SyncCompleted(std::move(token), status);
     return;
   }
 
   DCHECK(url_.is_valid());
   DCHECK(local_metadata_);
   DCHECK(local_changes_);
 
@@ skipping 19 matching lines @@
   }
 
   DCHECK_EQ(SYNC_FILE_TYPE_FILE, local_metadata_->file_type);
   file_type_ = SYNC_FILE_TYPE_DIRECTORY;
   sync_action_ = SYNC_ACTION_ADDED;
   // Got a remote folder for existing local file.
   // Our policy prioritize folders in this case.
   CreateFolder(std::move(token));
 }
 
-void RemoteToLocalSyncer::HandleDeletion(
-    scoped_ptr<SyncTaskToken> token) {
+void RemoteToLocalSyncer::HandleDeletion(std::unique_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) {
+void RemoteToLocalSyncer::HandleFileMove(std::unique_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,
+    std::unique_ptr<SyncTaskToken> token,
     SyncStatusCode status) {
   if (status != SYNC_STATUS_OK) {
     SyncCompleted(std::move(token), status);
     return;
   }
 
   DCHECK(url_.is_valid());
   DCHECK(local_metadata_);
   DCHECK(local_changes_);
 
@@ skipping 13 matching lines @@
     return;
   }
 
   DCHECK(local_changes_->back().IsAddOrUpdate());
   // File is remotely deleted and locally updated.
   // Ignore the remote deletion and handle it as if applied successfully.
   SyncCompleted(std::move(token), SYNC_STATUS_OK);
 }
 
 void RemoteToLocalSyncer::HandleContentUpdate(
-    scoped_ptr<SyncTaskToken> token) {
+    std::unique_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(), base::Passed(&token)));
 }
 
 void RemoteToLocalSyncer::ListFolderContent(
-    scoped_ptr<SyncTaskToken> token) {
+    std::unique_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(),
-                 base::Passed(&token),
-                 base::Passed(make_scoped_ptr(new FileIDList))));
+                 weak_ptr_factory_.GetWeakPtr(), base::Passed(&token),
+                 base::Passed(base::WrapUnique(new FileIDList))));
 }
 
 void RemoteToLocalSyncer::DidListFolderContent(
-    scoped_ptr<SyncTaskToken> token,
-    scoped_ptr<FileIDList> children,
+    std::unique_ptr<SyncTaskToken> token,
+    std::unique_ptr<FileIDList> children,
     google_apis::DriveApiErrorCode error,
-    scoped_ptr<google_apis::FileList> file_list) {
+    std::unique_ptr<google_apis::FileList> file_list) {
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
     SyncCompleted(std::move(token), status);
     return;
   }
 
   if (!file_list) {
     NOTREACHED();
     SyncCompleted(std::move(token), SYNC_STATUS_FAILED);
     return;
@@ skipping 14 matching lines @@
                    weak_ptr_factory_.GetWeakPtr(),
                    base::Passed(&token), base::Passed(&children)));
     return;
   }
 
   status = metadata_database()->PopulateFolderByChildList(
       dirty_tracker_->file_id(), *children);
   SyncCompleted(std::move(token), status);
 }
 
-void RemoteToLocalSyncer::SyncCompleted(scoped_ptr<SyncTaskToken> token,
+void RemoteToLocalSyncer::SyncCompleted(std::unique_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_) {
     FinalizeSync(std::move(token), SYNC_STATUS_OK);
     return;
   }
@@ skipping 23 matching lines @@
       updated_details.clear_md5();
       updated_details.set_missing(true);
     }
   }
 
   status = metadata_database()->UpdateTracker(
       dirty_tracker_->tracker_id(), updated_details);
   FinalizeSync(std::move(token), status);
 }
 
-void RemoteToLocalSyncer::FinalizeSync(scoped_ptr<SyncTaskToken> token,
+void RemoteToLocalSyncer::FinalizeSync(std::unique_ptr<SyncTaskToken> token,
                                        SyncStatusCode status) {
   if (prepared_) {
     remote_change_processor()->FinalizeRemoteSync(
         url_, false /* clear_local_change */,
         base::Bind(SyncTaskManager::NotifyTaskDone,
                    base::Passed(&token), status));
     return;
   }
 
   SyncTaskManager::NotifyTaskDone(std::move(token), status);
@@ skipping 17 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(scoped_ptr<SyncTaskToken> token) {
+void RemoteToLocalSyncer::DeleteLocalFile(
+    std::unique_ptr<SyncTaskToken> token) {
   remote_change_processor()->ApplyRemoteChange(
       FileChange(FileChange::FILE_CHANGE_DELETE, SYNC_FILE_TYPE_UNKNOWN),
       base::FilePath(), url_, SyncCompletedCallback(std::move(token)));
 }
 
-void RemoteToLocalSyncer::DownloadFile(scoped_ptr<SyncTaskToken> token) {
+void RemoteToLocalSyncer::DownloadFile(std::unique_ptr<SyncTaskToken> token) {
   DCHECK(sync_context_->GetWorkerTaskRunner()->RunsTasksOnCurrentThread());
 
   storage::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(),
                  base::Passed(&token), base::Passed(&file)),
       google_apis::GetContentCallback(),
       google_apis::ProgressCallback());
 }
 
-void RemoteToLocalSyncer::DidDownloadFile(scoped_ptr<SyncTaskToken> token,
+void RemoteToLocalSyncer::DidDownloadFile(std::unique_ptr<SyncTaskToken> token,
                                           storage::ScopedFile file,
                                           google_apis::DriveApiErrorCode error,
                                           const base::FilePath&) {
   DCHECK(sync_context_->GetWorkerTaskRunner()->RunsTasksOnCurrentThread());
 
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
     SyncCompleted(std::move(token), status);
     return;
   }
@@ skipping 12 matching lines @@
   }
 
   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(),
                  base::Passed(&token), base::Passed(&file)));
 }
 
-void RemoteToLocalSyncer::DidApplyDownload(scoped_ptr<SyncTaskToken> token,
+void RemoteToLocalSyncer::DidApplyDownload(std::unique_ptr<SyncTaskToken> token,
                                            storage::ScopedFile,
                                            SyncStatusCode status) {
   SyncCompleted(std::move(token), status);
 }
 
-void RemoteToLocalSyncer::CreateFolder(scoped_ptr<SyncTaskToken> token) {
+void RemoteToLocalSyncer::CreateFolder(std::unique_ptr<SyncTaskToken> token) {
   remote_change_processor()->ApplyRemoteChange(
       FileChange(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
                  SYNC_FILE_TYPE_DIRECTORY),
       base::FilePath(), url_, SyncCompletedCallback(std::move(token)));
 }
 
 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) {
+    std::unique_ptr<SyncTaskToken> token) {
   return base::Bind(&RemoteToLocalSyncer::SyncCompleted,
                     weak_ptr_factory_.GetWeakPtr(),
                     base::Passed(&token));
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system