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

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 <utility>
 #include <vector>
 
@@ skipping 19 matching lines @@
 #include "components/drive/service/drive_service_interface.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "net/base/mime_util.h"
 #include "storage/common/fileapi/file_system_util.h"
 
 namespace sync_file_system {
 namespace drive_backend {
 
 namespace {
 
-scoped_ptr<FileTracker> FindTrackerByID(MetadataDatabase* metadata_database,
-                                        int64_t tracker_id) {
-  scoped_ptr<FileTracker> tracker(new FileTracker);
+std::unique_ptr<FileTracker> FindTrackerByID(
+    MetadataDatabase* metadata_database,
+    int64_t tracker_id) {
+  std::unique_ptr<FileTracker> tracker(new FileTracker);
   if (metadata_database->FindTrackerByTrackerID(tracker_id, tracker.get()))
     return tracker;
-  return scoped_ptr<FileTracker>();
+  return std::unique_ptr<FileTracker>();
 }
 
 bool GetKnownChangeID(MetadataDatabase* metadata_database,
                       const std::string& file_id,
                       int64_t* change_id) {
   FileMetadata remote_file_metadata;
   if (!metadata_database->FindFileByFileID(file_id, &remote_file_metadata))
     return false;
   *change_id = remote_file_metadata.details().change_id();
   return true;
@@ 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::RunPreflight(scoped_ptr<SyncTaskToken> token) {
+void LocalToRemoteSyncer::RunPreflight(std::unique_ptr<SyncTaskToken> token) {
   token->InitializeTaskLog("Local -> Remote");
 
   if (!IsContextReady()) {
     token->RecordLog("Context not ready.");
     SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
 
   token->RecordLog(base::StringPrintf(
       "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.
     token->RecordLog("Missing file for non-delete change.");
     SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_OK);
     return;
   }
 
   std::string app_id = url_.origin().host();
   base::FilePath path = url_.path();
 
-  scoped_ptr<FileTracker> active_ancestor_tracker(new FileTracker);
+  std::unique_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.
     token->RecordLog("App is disabled or not registered");
     SyncTaskManager::NotifyTaskDone(std::move(token),
                                     SYNC_STATUS_UNKNOWN_ORIGIN);
     return;
   }
@@ skipping 107 matching lines @@
                      std::move(token));
     return;
   }
 
   token->RecordLog("Detected a new folder.");
   MoveToBackground(base::Bind(&LocalToRemoteSyncer::CreateRemoteFolder,
                               weak_ptr_factory_.GetWeakPtr()),
                    std::move(token));
 }
 
-void LocalToRemoteSyncer::MoveToBackground(const Continuation& continuation,
-                                           scoped_ptr<SyncTaskToken> token) {
-  scoped_ptr<TaskBlocker> blocker(new TaskBlocker);
+void LocalToRemoteSyncer::MoveToBackground(
+    const Continuation& continuation,
+    std::unique_ptr<SyncTaskToken> token) {
+  std::unique_ptr<TaskBlocker> blocker(new TaskBlocker);
   blocker->app_id = url_.origin().host();
   blocker->paths.push_back(target_path_);
 
   if (remote_file_tracker_) {
     if (!GetKnownChangeID(metadata_database(),
                           remote_file_tracker_->file_id(),
                           &remote_file_change_id_)) {
       NOTREACHED();
       SyncCompleted(std::move(token), SYNC_STATUS_FAILED);
       return;
     }
 
     blocker->tracker_ids.push_back(remote_file_tracker_->tracker_id());
     blocker->file_ids.push_back(remote_file_tracker_->file_id());
   }
 
   // Run current task as a background task with |blocker|.
   // After the invocation of ContinueAsBackgroundTask
   SyncTaskManager::UpdateTaskBlocker(
       std::move(token), std::move(blocker),
       base::Bind(&LocalToRemoteSyncer::ContinueAsBackgroundTask,
                  weak_ptr_factory_.GetWeakPtr(), continuation));
 }
 
 void LocalToRemoteSyncer::ContinueAsBackgroundTask(
     const Continuation& continuation,
-    scoped_ptr<SyncTaskToken> token) {
+    std::unique_ptr<SyncTaskToken> token) {
   // The SyncTask runs as a background task beyond this point.
   // Note that any task can run between MoveToBackground() and
   // ContinueAsBackgroundTask(), so we need to make sure other tasks didn't
   // affect to the current LocalToRemoteSyncer task.
   //
   // - For RemoteToLocalSyncer, it doesn't actually run beyond
   //   PrepareForProcessRemoteChange() since it should be blocked in
   //   LocalFileSyncService.
   // - For ListChangesTask, it may update FileMetatada together with |change_id|
   //   and may delete FileTracker.  So, ensure |change_id| is not changed and
@@ skipping 15 matching lines @@
     if (!metadata_database()->FindTrackerByTrackerID(
             remote_file_tracker_->tracker_id(), nullptr)) {
       SyncCompleted(std::move(token), SYNC_STATUS_RETRY);
       return;
     }
   }
 
   continuation.Run(std::move(token));
 }
 
-void LocalToRemoteSyncer::SyncCompleted(scoped_ptr<SyncTaskToken> token,
+void LocalToRemoteSyncer::SyncCompleted(std::unique_ptr<SyncTaskToken> token,
                                         SyncStatusCode status) {
   if (status == SYNC_STATUS_OK && retry_on_success_)
     status = SYNC_STATUS_RETRY;
 
   if (needs_remote_change_listing_)
     status = SYNC_STATUS_FILE_BUSY;
 
   token->RecordLog(base::StringPrintf(
       "Finished: action=%s, status=%s for %s@%s",
       SyncActionToString(sync_action_),
       SyncStatusCodeToString(status),
       target_path_.AsUTF8Unsafe().c_str(),
       url_.origin().host().c_str()));
 
   SyncTaskManager::NotifyTaskDone(std::move(token), status);
 }
 
-void LocalToRemoteSyncer::HandleConflict(scoped_ptr<SyncTaskToken> token) {
+void LocalToRemoteSyncer::HandleConflict(std::unique_ptr<SyncTaskToken> token) {
   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_) {
     SyncCompleted(std::move(token), SYNC_STATUS_OK);
     return;
   }
 
@@ skipping 32 matching lines @@
     return;
   }
 
   MoveToBackground(base::Bind(&LocalToRemoteSyncer::CreateRemoteFolder,
                               weak_ptr_factory_.GetWeakPtr()),
                    std::move(token));
 }
 
 void LocalToRemoteSyncer::UpdateTrackerForReusedFolder(
     const FileDetails& details,
-    scoped_ptr<SyncTaskToken> token) {
+    std::unique_ptr<SyncTaskToken> token) {
   SyncStatusCode status = metadata_database()->UpdateTracker(
       remote_file_tracker_->tracker_id(), details);
   SyncCompleted(std::move(token), status);
 }
 
 void LocalToRemoteSyncer::HandleExistingRemoteFile(
-    scoped_ptr<SyncTaskToken> token) {
+    std::unique_ptr<SyncTaskToken> token) {
   DCHECK(remote_file_tracker_);
   DCHECK(!remote_file_tracker_->dirty());
   DCHECK(remote_file_tracker_->active());
   DCHECK(remote_file_tracker_->has_synced_details());
 
   if (local_is_missing_) {
     // Local file deletion for existing remote file.
     MoveToBackground(base::Bind(&LocalToRemoteSyncer::DeleteRemoteFile,
                                 weak_ptr_factory_.GetWeakPtr()),
                      std::move(token));
@@ skipping 36 matching lines @@
                                 weak_ptr_factory_.GetWeakPtr()),
                      std::move(token));
     return;
   }
 
   // Non-conflicting local folder creation to existing remote folder.
   DCHECK_EQ(FILE_KIND_FOLDER, synced_details.file_kind());
   SyncCompleted(std::move(token), SYNC_STATUS_OK);
 }
 
-void LocalToRemoteSyncer::DeleteRemoteFile(scoped_ptr<SyncTaskToken> token) {
+void LocalToRemoteSyncer::DeleteRemoteFile(
+    std::unique_ptr<SyncTaskToken> token) {
   DCHECK(remote_file_tracker_);
   DCHECK(remote_file_tracker_->has_synced_details());
 
   switch (remote_file_tracker_->synced_details().file_kind()) {
     case FILE_KIND_UNSUPPORTED:
       NOTREACHED();
       file_type_ = SYNC_FILE_TYPE_UNKNOWN;
       break;
     case FILE_KIND_FILE:
       file_type_ = SYNC_FILE_TYPE_FILE;
       break;
     case FILE_KIND_FOLDER:
       file_type_ = SYNC_FILE_TYPE_DIRECTORY;
       break;
   }
   sync_action_ = SYNC_ACTION_DELETED;
   drive_service()->DeleteResource(
       remote_file_tracker_->file_id(),
       remote_file_tracker_->synced_details().etag(),
       base::Bind(&LocalToRemoteSyncer::DidDeleteRemoteFile,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
 }
 
 void LocalToRemoteSyncer::DidDeleteRemoteFile(
-    scoped_ptr<SyncTaskToken> token,
+    std::unique_ptr<SyncTaskToken> token,
     google_apis::DriveApiErrorCode error) {
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK &&
       error != google_apis::HTTP_NOT_FOUND &&
       error != google_apis::HTTP_PRECONDITION &&
       error != google_apis::HTTP_CONFLICT) {
     SyncCompleted(std::move(token), status);
     return;
   }
 
   // Handle NOT_FOUND case as SUCCESS case.
   // For PRECONDITION / CONFLICT case, the remote file is modified since the
   // last sync completed.  As our policy for deletion-modification conflict
   // resolution, ignore the local deletion.
   if (status == SYNC_STATUS_OK ||
       error == google_apis::HTTP_NOT_FOUND) {
     SyncStatusCode status = metadata_database()->UpdateByDeletedRemoteFile(
         remote_file_tracker_->file_id());
     SyncCompleted(std::move(token), status);
     return;
   }
 
   SyncCompleted(std::move(token), SYNC_STATUS_OK);
 }
 
-void LocalToRemoteSyncer::UploadExistingFile(scoped_ptr<SyncTaskToken> token) {
+void LocalToRemoteSyncer::UploadExistingFile(
+    std::unique_ptr<SyncTaskToken> token) {
   DCHECK(remote_file_tracker_);
   DCHECK(remote_file_tracker_->has_synced_details());
   DCHECK(sync_context_->GetWorkerTaskRunner()->RunsTasksOnCurrentThread());
 
   const std::string local_file_md5 = drive::util::GetMd5Digest(local_path_,
                                                                nullptr);
   if (local_file_md5 == remote_file_tracker_->synced_details().md5()) {
     // Local file is not changed.
     SyncCompleted(std::move(token), SYNC_STATUS_OK);
     return;
   }
 
   file_type_ = SYNC_FILE_TYPE_FILE;
   sync_action_ = SYNC_ACTION_UPDATED;
 
   drive::UploadExistingFileOptions options;
   options.etag = remote_file_tracker_->synced_details().etag();
   drive_uploader()->UploadExistingFile(
       remote_file_tracker_->file_id(),
       local_path_,
       "application/octet_stream",
       options,
       base::Bind(&LocalToRemoteSyncer::DidUploadExistingFile,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)),
       google_apis::ProgressCallback());
 }
 
 void LocalToRemoteSyncer::DidUploadExistingFile(
-    scoped_ptr<SyncTaskToken> token,
+    std::unique_ptr<SyncTaskToken> token,
     google_apis::DriveApiErrorCode error,
     const GURL&,
-    scoped_ptr<google_apis::FileResource> entry) {
+    std::unique_ptr<google_apis::FileResource> entry) {
   if (error == google_apis::HTTP_PRECONDITION ||
       error == google_apis::HTTP_CONFLICT ||
       error == google_apis::HTTP_NOT_FOUND) {
     // The remote file has unfetched remote change.  Fetch latest metadata and
     // update database with it.
     // TODO(tzik): Consider adding local side low-priority dirtiness handling to
     // handle this as ListChangesTask.
 
     needs_remote_change_listing_ = true;
     UpdateRemoteMetadata(remote_file_tracker_->file_id(), std::move(token));
@@ skipping 38 matching lines @@
         remote_file_tracker_->tracker_id(), file.details());
     SyncCompleted(std::move(token), status);
     return;
   }
 
   SyncCompleted(std::move(token), SYNC_STATUS_RETRY);
 }
 
 void LocalToRemoteSyncer::UpdateRemoteMetadata(
     const std::string& file_id,
-    scoped_ptr<SyncTaskToken> token) {
+    std::unique_ptr<SyncTaskToken> token) {
   DCHECK(remote_file_tracker_);
 
   drive_service()->GetFileResource(
       file_id,
       base::Bind(&LocalToRemoteSyncer::DidGetRemoteMetadata,
                  weak_ptr_factory_.GetWeakPtr(),
                  file_id, base::Passed(&token)));
 }
 
 void LocalToRemoteSyncer::DidGetRemoteMetadata(
     const std::string& file_id,
-    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());
 
   if (error == google_apis::HTTP_NOT_FOUND) {
     retry_on_success_ = true;
     SyncStatusCode status =
         metadata_database()->UpdateByDeletedRemoteFile(file_id);
     SyncCompleted(std::move(token), status);
     return;
   }
 
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
     SyncCompleted(std::move(token), status);
     return;
   }
 
   if (!entry) {
     NOTREACHED();
     SyncCompleted(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
 
   retry_on_success_ = true;
   status = metadata_database()->UpdateByFileResource(*entry);
   SyncCompleted(std::move(token), status);
 }
 
-void LocalToRemoteSyncer::UploadNewFile(scoped_ptr<SyncTaskToken> token) {
+void LocalToRemoteSyncer::UploadNewFile(std::unique_ptr<SyncTaskToken> token) {
   DCHECK(remote_parent_folder_tracker_);
 
   file_type_ = SYNC_FILE_TYPE_FILE;
   sync_action_ = SYNC_ACTION_ADDED;
   base::FilePath title = storage::VirtualPath::BaseName(target_path_);
   drive_uploader()->UploadNewFile(
       remote_parent_folder_tracker_->file_id(), local_path_,
       title.AsUTF8Unsafe(), GetMimeTypeFromTitle(title),
       drive::UploadNewFileOptions(),
       base::Bind(&LocalToRemoteSyncer::DidUploadNewFile,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)),
       google_apis::ProgressCallback());
 }
 
 void LocalToRemoteSyncer::DidUploadNewFile(
-    scoped_ptr<SyncTaskToken> token,
+    std::unique_ptr<SyncTaskToken> token,
     google_apis::DriveApiErrorCode error,
     const GURL& upload_location,
-    scoped_ptr<google_apis::FileResource> entry) {
+    std::unique_ptr<google_apis::FileResource> entry) {
   if (error == google_apis::HTTP_NOT_FOUND)
     needs_remote_change_listing_ = true;
 
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
     SyncCompleted(std::move(token), status);
     return;
   }
 
   if (!entry) {
     NOTREACHED();
     SyncCompleted(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
 
   status = metadata_database()->ReplaceActiveTrackerWithNewResource(
       remote_parent_folder_tracker_->tracker_id(), *entry);
   SyncCompleted(std::move(token), status);
 }
 
-void LocalToRemoteSyncer::CreateRemoteFolder(scoped_ptr<SyncTaskToken> token) {
+void LocalToRemoteSyncer::CreateRemoteFolder(
+    std::unique_ptr<SyncTaskToken> token) {
   DCHECK(remote_parent_folder_tracker_);
 
   base::FilePath title = storage::VirtualPath::BaseName(target_path_);
   file_type_ = SYNC_FILE_TYPE_DIRECTORY;
   sync_action_ = SYNC_ACTION_ADDED;
 
   DCHECK(!folder_creator_);
   folder_creator_.reset(new FolderCreator(
       drive_service(), metadata_database(),
       remote_parent_folder_tracker_->file_id(),
       title.AsUTF8Unsafe()));
   folder_creator_->Run(base::Bind(
       &LocalToRemoteSyncer::DidCreateRemoteFolder,
       weak_ptr_factory_.GetWeakPtr(),
       base::Passed(&token)));
 }
 
 void LocalToRemoteSyncer::DidCreateRemoteFolder(
-    scoped_ptr<SyncTaskToken> token,
+    std::unique_ptr<SyncTaskToken> token,
     const std::string& file_id,
     SyncStatusCode status) {
   if (status == SYNC_FILE_ERROR_NOT_FOUND)
     needs_remote_change_listing_ = true;
 
-  scoped_ptr<FolderCreator> deleter = std::move(folder_creator_);
+  std::unique_ptr<FolderCreator> deleter = std::move(folder_creator_);
   if (status != SYNC_STATUS_OK) {
     SyncCompleted(std::move(token), status);
     return;
   }
 
   status = SYNC_STATUS_FAILED;
   MetadataDatabase::ActivationStatus activation_status =
       metadata_database()->TryActivateTracker(
           remote_parent_folder_tracker_->tracker_id(),
           file_id, &status);
@@ skipping 11 matching lines @@
                      weak_ptr_factory_.GetWeakPtr(), base::Passed(&token)));
       return;
   }
 
   NOTREACHED();
   SyncCompleted(std::move(token), SYNC_STATUS_FAILED);
   return;
 }
 
 void LocalToRemoteSyncer::DidDetachResourceForCreationConflict(
-    scoped_ptr<SyncTaskToken> token,
+    std::unique_ptr<SyncTaskToken> token,
     google_apis::DriveApiErrorCode error) {
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
     SyncCompleted(std::move(token), status);
     return;
   }
 
   SyncCompleted(std::move(token), SYNC_STATUS_RETRY);
 }
 
@@ skipping 12 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