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

chrome/browser/sync_file_system/local/local_file_sync_context.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/local/local_file_sync_context.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
 #include "chrome/browser/sync_file_system/file_change.h"
 #include "chrome/browser/sync_file_system/local/local_file_change_tracker.h"
 #include "chrome/browser/sync_file_system/local/local_origin_change_observer.h"
 #include "chrome/browser/sync_file_system/local/root_delete_helper.h"
 #include "chrome/browser/sync_file_system/local/sync_file_system_backend.h"
 #include "chrome/browser/sync_file_system/local/syncable_file_operation_runner.h"
 #include "chrome/browser/sync_file_system/logger.h"
@@ skipping 612 matching lines @@
     return;
   }
   DCHECK(file_system_context);
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   if (!backend->change_tracker()) {
     // Create and initialize LocalFileChangeTracker and call back this method
     // later again.
     std::set<GURL>* origins_with_changes = new std::set<GURL>;
-    scoped_ptr<LocalFileChangeTracker>* tracker_ptr(
-        new scoped_ptr<LocalFileChangeTracker>);
+    std::unique_ptr<LocalFileChangeTracker>* tracker_ptr(
+        new std::unique_ptr<LocalFileChangeTracker>);
     base::PostTaskAndReplyWithResult(
         file_system_context->default_file_task_runner(), FROM_HERE,
         base::Bind(&LocalFileSyncContext::InitializeChangeTrackerOnFileThread,
                    this, tracker_ptr, base::RetainedRef(file_system_context),
                    origins_with_changes),
         base::Bind(&LocalFileSyncContext::DidInitializeChangeTrackerOnIOThread,
                    this, base::Owned(tracker_ptr), source_url,
                    base::RetainedRef(file_system_context),
                    base::Owned(origins_with_changes)));
     return;
   }
   if (!operation_runner_) {
     DCHECK(!sync_status_);
     DCHECK(!timer_on_io_);
     sync_status_.reset(new LocalFileSyncStatus);
     timer_on_io_.reset(new base::OneShotTimer);
     operation_runner_.reset(new SyncableFileOperationRunner(
             kMaxConcurrentSyncableOperation,
             sync_status_.get()));
     sync_status_->AddObserver(this);
   }
   backend->set_sync_context(this);
   DidInitialize(source_url, file_system_context,
                 SYNC_STATUS_OK);
 }
 
 SyncStatusCode LocalFileSyncContext::InitializeChangeTrackerOnFileThread(
-    scoped_ptr<LocalFileChangeTracker>* tracker_ptr,
+    std::unique_ptr<LocalFileChangeTracker>* tracker_ptr,
     FileSystemContext* file_system_context,
     std::set<GURL>* origins_with_changes) {
   DCHECK(file_system_context);
   DCHECK(tracker_ptr);
   DCHECK(origins_with_changes);
   tracker_ptr->reset(new LocalFileChangeTracker(
           file_system_context->partition_path(),
           env_override_,
           file_system_context->default_file_task_runner()));
   const SyncStatusCode status = (*tracker_ptr)->Initialize(file_system_context);
   if (status != SYNC_STATUS_OK)
     return status;
 
   // Get all origins that have pending changes.
   FileSystemURLQueue urls;
   (*tracker_ptr)->GetNextChangedURLs(&urls, 0);
   for (FileSystemURLQueue::iterator iter = urls.begin();
        iter != urls.end(); ++iter) {
     origins_with_changes->insert(iter->origin());
   }
 
   // Creates snapshot directory.
   base::CreateDirectory(local_base_path_.Append(kSnapshotDir));
 
   return status;
 }
 
 void LocalFileSyncContext::DidInitializeChangeTrackerOnIOThread(
-    scoped_ptr<LocalFileChangeTracker>* tracker_ptr,
+    std::unique_ptr<LocalFileChangeTracker>* tracker_ptr,
     const GURL& source_url,
     FileSystemContext* file_system_context,
     std::set<GURL>* origins_with_changes,
     SyncStatusCode status) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(file_system_context);
   DCHECK(origins_with_changes);
   if (shutdown_on_io_)
     status = SYNC_STATUS_ABORT;
   if (status != SYNC_STATUS_OK) {
@@ skipping 39 matching lines @@
 
   StatusCallbackQueue& callback_queue =
       pending_initialize_callbacks_[file_system_context];
   for (StatusCallbackQueue::iterator iter = callback_queue.begin();
        iter != callback_queue.end(); ++iter) {
     ui_task_runner_->PostTask(FROM_HERE, base::Bind(*iter, status));
   }
   pending_initialize_callbacks_.erase(file_system_context);
 }
 
-scoped_ptr<LocalFileSyncContext::FileSystemURLQueue>
+std::unique_ptr<LocalFileSyncContext::FileSystemURLQueue>
 LocalFileSyncContext::GetNextURLsForSyncOnFileThread(
     FileSystemContext* file_system_context) {
   DCHECK(file_system_context);
   DCHECK(file_system_context->default_file_task_runner()->
              RunsTasksOnCurrentThread());
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
-  scoped_ptr<FileSystemURLQueue> urls(new FileSystemURLQueue);
+  std::unique_ptr<FileSystemURLQueue> urls(new FileSystemURLQueue);
   backend->change_tracker()->GetNextChangedURLs(
       urls.get(), kMaxURLsToFetchForLocalSync);
   for (FileSystemURLQueue::iterator iter = urls->begin();
        iter != urls->end(); ++iter)
     backend->change_tracker()->DemoteChangesForURL(*iter);
 
   return urls;
 }
 
 void LocalFileSyncContext::TryPrepareForLocalSync(
     FileSystemContext* file_system_context,
     const LocalFileSyncInfoCallback& callback,
-    scoped_ptr<FileSystemURLQueue> urls) {
+    std::unique_ptr<FileSystemURLQueue> urls) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(urls);
 
   if (shutdown_on_ui_) {
     callback.Run(SYNC_STATUS_ABORT, LocalFileSyncInfo(), storage::ScopedFile());
     return;
   }
 
   if (urls->empty()) {
     callback.Run(SYNC_STATUS_NO_CHANGE_TO_SYNC,
                  LocalFileSyncInfo(),
                  storage::ScopedFile());
     return;
   }
 
   const FileSystemURL url = urls->front();
   urls->pop_front();
 
   PrepareForSync(file_system_context, url, SYNC_SNAPSHOT,
                  base::Bind(&LocalFileSyncContext::DidTryPrepareForLocalSync,
                             this, base::RetainedRef(file_system_context),
                             base::Passed(&urls), callback));
 }
 
 void LocalFileSyncContext::DidTryPrepareForLocalSync(
     FileSystemContext* file_system_context,
-    scoped_ptr<FileSystemURLQueue> remaining_urls,
+    std::unique_ptr<FileSystemURLQueue> remaining_urls,
     const LocalFileSyncInfoCallback& callback,
     SyncStatusCode status,
     const LocalFileSyncInfo& sync_file_info,
     storage::ScopedFile snapshot) {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   if (status != SYNC_STATUS_FILE_BUSY) {
     PromoteDemotedChangesForURLs(file_system_context,
                                  std::move(remaining_urls));
     callback.Run(status, sync_file_info, std::move(snapshot));
     return;
@@ skipping 24 matching lines @@
 
   SyncFileSystemBackend* backend =
       SyncFileSystemBackend::GetBackend(file_system_context);
   DCHECK(backend);
   DCHECK(backend->change_tracker());
   backend->change_tracker()->PromoteDemotedChangesForURL(url);
 }
 
 void LocalFileSyncContext::PromoteDemotedChangesForURLs(
     FileSystemContext* file_system_context,
-    scoped_ptr<FileSystemURLQueue> urls) {
+    std::unique_ptr<FileSystemURLQueue> urls) {
   DCHECK(file_system_context);
   if (!file_system_context->default_file_task_runner()->
           RunsTasksOnCurrentThread()) {
     DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
     if (shutdown_on_ui_)
       return;
     file_system_context->default_file_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&LocalFileSyncContext::PromoteDemotedChangesForURLs, this,
                    base::RetainedRef(file_system_context),
@@ skipping 36 matching lines @@
   FileChangeList changes;
   backend->change_tracker()->GetChangesForURL(url, &changes);
 
   base::FilePath platform_path;
   base::File::Info file_info;
   FileSystemFileUtil* file_util =
       file_system_context->sandbox_delegate()->sync_file_util();
   DCHECK(file_util);
 
   base::File::Error file_error = file_util->GetFileInfo(
-      make_scoped_ptr(
-          new FileSystemOperationContext(file_system_context)).get(),
-      url,
-      &file_info,
-      &platform_path);
+      base::WrapUnique(new FileSystemOperationContext(file_system_context))
+          .get(),
+      url, &file_info, &platform_path);
 
   storage::ScopedFile snapshot;
   if (file_error == base::File::FILE_OK && sync_mode == SYNC_SNAPSHOT) {
     base::FilePath snapshot_path;
     base::CreateTemporaryFileInDir(local_base_path_.Append(kSnapshotDir),
                                    &snapshot_path);
     if (base::CopyFile(platform_path, snapshot_path)) {
       platform_path = snapshot_path;
       snapshot =
           storage::ScopedFile(snapshot_path,
@@ skipping 120 matching lines @@
     return;
   }
 
   FileSystemURL url_for_sync = CreateSyncableFileSystemURLForSync(
       file_system_context, dest_url);
   file_system_context->operation_runner()->CopyInForeignFile(
       local_path, url_for_sync, callback);
 }
 
 }  // namespace sync_file_system