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

chrome/browser/sync_file_system/sync_file_system_service.cc

 // Copyright (c) 2012 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/sync_file_system_service.h"
 
 #include <stddef.h>
 #include <stdint.h>
+
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/extensions/api/sync_file_system/extension_sync_event_observer.h"
 #include "chrome/browser/extensions/api/sync_file_system/sync_file_system_api_helpers.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync_file_system/local/local_file_sync_service.h"
@@ skipping 415 matching lines @@
   CheckIfIdle();
 }
 
 SyncFileSystemService::SyncFileSystemService(Profile* profile)
     : profile_(profile),
       sync_enabled_(true),
       promoting_demoted_changes_(false) {
 }
 
 void SyncFileSystemService::Initialize(
-    scoped_ptr<LocalFileSyncService> local_service,
-    scoped_ptr<RemoteFileSyncService> remote_service) {
+    std::unique_ptr<LocalFileSyncService> local_service,
+    std::unique_ptr<RemoteFileSyncService> remote_service) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(local_service);
   DCHECK(remote_service);
   DCHECK(profile_);
 
   local_service_ = std::move(local_service);
   remote_service_ = std::move(remote_service);
 
-  scoped_ptr<LocalSyncRunner> local_syncer(
+  std::unique_ptr<LocalSyncRunner> local_syncer(
       new LocalSyncRunner(kLocalSyncName, this));
-  scoped_ptr<RemoteSyncRunner> remote_syncer(
+  std::unique_ptr<RemoteSyncRunner> remote_syncer(
       new RemoteSyncRunner(kRemoteSyncName, this, remote_service_.get()));
 
   local_service_->AddChangeObserver(local_syncer.get());
   local_service_->SetLocalChangeProcessorCallback(
       base::Bind(&GetLocalChangeProcessorAdapter, AsWeakPtr()));
 
   remote_service_->AddServiceObserver(remote_syncer.get());
   remote_service_->AddFileStatusObserver(this);
   remote_service_->SetRemoteChangeProcessor(local_service_.get());
 
@@ skipping 91 matching lines @@
       base::Bind(
           &SyncFileSystemService::DidDumpFiles,
           AsWeakPtr(),
           origin,
           callback));
 }
 
 void SyncFileSystemService::DidDumpFiles(
     const GURL& origin,
     const DumpFilesCallback& callback,
-    scoped_ptr<base::ListValue> dump_files) {
+    std::unique_ptr<base::ListValue> dump_files) {
   if (!dump_files || !dump_files->GetSize() ||
       !local_service_ || !remote_service_) {
     callback.Run(base::ListValue());
     return;
   }
 
   base::ListValue* files = dump_files.get();
   base::Callback<void(base::DictionaryValue*,
                       SyncStatusCode,
                       SyncFileStatus)> completion_callback =
@@ skipping 13 matching lines @@
           nullptr, SYNC_FILE_ERROR_FAILED, SYNC_FILE_STATUS_UNKNOWN);
       continue;
     }
 
     base::FilePath file_path = base::FilePath::FromUTF8Unsafe(path_string);
     FileSystemURL url = CreateSyncableFileSystemURL(origin, file_path);
     GetFileSyncStatus(url, base::Bind(completion_callback, file));
   }
 }
 
-void SyncFileSystemService::DidDumpDatabase(const DumpFilesCallback& callback,
-                                            scoped_ptr<base::ListValue> list) {
+void SyncFileSystemService::DidDumpDatabase(
+    const DumpFilesCallback& callback,
+    std::unique_ptr<base::ListValue> list) {
   if (!list)
-    list = make_scoped_ptr(new base::ListValue);
+    list = base::WrapUnique(new base::ListValue);
   callback.Run(*list);
 }
 
 void SyncFileSystemService::DidGetExtensionStatusMap(
     const ExtensionStatusMapCallback& callback,
-    scoped_ptr<RemoteFileSyncService::OriginStatusMap> status_map) {
+    std::unique_ptr<RemoteFileSyncService::OriginStatusMap> status_map) {
   if (!status_map)
-    status_map = make_scoped_ptr(new RemoteFileSyncService::OriginStatusMap);
+    status_map = base::WrapUnique(new RemoteFileSyncService::OriginStatusMap);
   callback.Run(*status_map);
 }
 
 void SyncFileSystemService::SetSyncEnabledForTesting(bool enabled) {
   sync_enabled_ = enabled;
   remote_service_->SetSyncEnabled(sync_enabled_);
 }
 
 void SyncFileSystemService::DidGetLocalChangeStatus(
     const SyncFileStatusCallback& callback,
@@ skipping 131 matching lines @@
            local_sync_runners_.begin();
        iter != local_sync_runners_.end(); ++iter)
     ((*iter)->*method)();
   for (ScopedVector<SyncProcessRunner>::iterator iter =
            remote_sync_runners_.begin();
        iter != remote_sync_runners_.end(); ++iter)
     ((*iter)->*method)();
 }
 
 }  // namespace sync_file_system