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

chrome/browser/sync_file_system/drive_backend/conflict_resolver.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/conflict_resolver.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/callback.h"
@@ skipping 15 matching lines @@
 
 namespace sync_file_system {
 namespace drive_backend {
 
 ConflictResolver::ConflictResolver(SyncEngineContext* sync_context)
     : sync_context_(sync_context),
       weak_ptr_factory_(this) {}
 
 ConflictResolver::~ConflictResolver() {}
 
-void ConflictResolver::RunPreflight(scoped_ptr<SyncTaskToken> token) {
+void ConflictResolver::RunPreflight(std::unique_ptr<SyncTaskToken> token) {
   token->InitializeTaskLog("Conflict Resolution");
 
-  scoped_ptr<TaskBlocker> task_blocker(new TaskBlocker);
+  std::unique_ptr<TaskBlocker> task_blocker(new TaskBlocker);
   task_blocker->exclusive = true;
   SyncTaskManager::UpdateTaskBlocker(
       std::move(token), std::move(task_blocker),
       base::Bind(&ConflictResolver::RunExclusive,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
-void ConflictResolver::RunExclusive(scoped_ptr<SyncTaskToken> token) {
+void ConflictResolver::RunExclusive(std::unique_ptr<SyncTaskToken> token) {
   if (!IsContextReady()) {
     SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_FAILED);
     return;
   }
 
   // Conflict resolution should be invoked on clean tree.
   if (metadata_database()->HasDirtyTracker()) {
     SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_RETRY);
     return;
   }
@@ skipping 63 matching lines @@
         non_primary_file_ids_.size(), primary_tracker_id));
 
     RemoveNonPrimaryFiles(std::move(token));
     return;
   }
 
   SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_NO_CONFLICT);
 }
 
 void ConflictResolver::DetachFromNonPrimaryParents(
-    scoped_ptr<SyncTaskToken> token) {
+    std::unique_ptr<SyncTaskToken> token) {
   DCHECK(!parents_to_remove_.empty());
 
   // TODO(tzik): Check if ETag match is available for
   // RemoteResourceFromDirectory.
   std::string parent_folder_id = parents_to_remove_.back();
   parents_to_remove_.pop_back();
 
   token->RecordLog(base::StringPrintf(
       "Detach %s from %s",
       target_file_id_.c_str(), parent_folder_id.c_str()));
 
   drive_service()->RemoveResourceFromDirectory(
       parent_folder_id, target_file_id_,
       base::Bind(&ConflictResolver::DidDetachFromParent,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&token)));
 }
 
 void ConflictResolver::DidDetachFromParent(
-    scoped_ptr<SyncTaskToken> token,
+    std::unique_ptr<SyncTaskToken> token,
     google_apis::DriveApiErrorCode error) {
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK) {
     SyncTaskManager::NotifyTaskDone(std::move(token), status);
     return;
   }
 
   if (!parents_to_remove_.empty()) {
     DetachFromNonPrimaryParents(std::move(token));
     return;
   }
 
   SyncTaskManager::NotifyTaskDone(std::move(token), SYNC_STATUS_OK);
 }
 
 std::string ConflictResolver::PickPrimaryFile(const TrackerIDSet& trackers) {
-  scoped_ptr<FileMetadata> primary;
+  std::unique_ptr<FileMetadata> primary;
   for (TrackerIDSet::const_iterator itr = trackers.begin();
        itr != trackers.end(); ++itr) {
     FileTracker tracker;
     if (!metadata_database()->FindTrackerByTrackerID(*itr, &tracker)) {
       NOTREACHED();
       continue;
     }
 
-    scoped_ptr<FileMetadata> file_metadata(new FileMetadata);
+    std::unique_ptr<FileMetadata> file_metadata(new FileMetadata);
     if (!metadata_database()->FindFileByFileID(
             tracker.file_id(), file_metadata.get())) {
       NOTREACHED();
       continue;
     }
 
     if (!primary) {
       primary = std::move(file_metadata);
       continue;
     }
@@ skipping 34 matching lines @@
       primary = std::move(file_metadata);
       continue;
     }
   }
 
   if (primary)
     return primary->file_id();
   return std::string();
 }
 
-void ConflictResolver::RemoveNonPrimaryFiles(scoped_ptr<SyncTaskToken> token) {
+void ConflictResolver::RemoveNonPrimaryFiles(
+    std::unique_ptr<SyncTaskToken> token) {
   DCHECK(!non_primary_file_ids_.empty());
 
   std::string file_id = non_primary_file_ids_.back().first;
   std::string etag = non_primary_file_ids_.back().second;
   non_primary_file_ids_.pop_back();
 
   DCHECK_NE(target_file_id_, file_id);
 
   token->RecordLog(base::StringPrintf(
       "Remove non-primary file %s", file_id.c_str()));
 
   // TODO(tzik): Check if the file is a folder, and merge its contents into
   // the folder identified by |target_file_id_|.
   drive_service()->DeleteResource(
       file_id, etag,
       base::Bind(&ConflictResolver::DidRemoveFile,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(&token), file_id));
 }
 
-void ConflictResolver::DidRemoveFile(scoped_ptr<SyncTaskToken> token,
+void ConflictResolver::DidRemoveFile(std::unique_ptr<SyncTaskToken> token,
                                      const std::string& file_id,
                                      google_apis::DriveApiErrorCode error) {
   if (error == google_apis::HTTP_PRECONDITION ||
       error == google_apis::HTTP_CONFLICT) {
     UpdateFileMetadata(file_id, std::move(token));
     return;
   }
 
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK && error != google_apis::HTTP_NOT_FOUND) {
@@ skipping 12 matching lines @@
   SyncTaskManager::NotifyTaskDone(std::move(token), status);
 }
 
 bool ConflictResolver::IsContextReady() {
   return sync_context_->GetDriveService() &&
       sync_context_->GetMetadataDatabase();
 }
 
 void ConflictResolver::UpdateFileMetadata(
     const std::string& file_id,
-    scoped_ptr<SyncTaskToken> token) {
+    std::unique_ptr<SyncTaskToken> token) {
   drive_service()->GetFileResource(
       file_id,
       base::Bind(&ConflictResolver::DidGetRemoteMetadata,
                  weak_ptr_factory_.GetWeakPtr(), file_id,
                  base::Passed(&token)));
 }
 
 void ConflictResolver::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) {
   SyncStatusCode status = DriveApiErrorCodeToSyncStatusCode(error);
   if (status != SYNC_STATUS_OK && error != google_apis::HTTP_NOT_FOUND) {
     SyncTaskManager::NotifyTaskDone(std::move(token), status);
     return;
   }
 
   if (error != google_apis::HTTP_NOT_FOUND) {
     status = metadata_database()->UpdateByDeletedRemoteFile(file_id);
     SyncTaskManager::NotifyTaskDone(std::move(token), status);
     return;
@@ skipping 13 matching lines @@
   set_used_network(true);
   return sync_context_->GetDriveService();
 }
 
 MetadataDatabase* ConflictResolver::metadata_database() {
   return sync_context_->GetMetadataDatabase();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system