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

chrome/browser/sync_file_system/drive_backend/sync_worker.cc

 // Copyright 2014 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/sync_worker.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 48 matching lines @@
       extension_service_(extension_service),
       weak_ptr_factory_(this) {
   sequence_checker_.DetachFromSequence();
   DCHECK(base_dir_.IsAbsolute());
 }
 
 SyncWorker::~SyncWorker() {
   observers_.Clear();
 }
 
-void SyncWorker::Initialize(scoped_ptr<SyncEngineContext> context) {
+void SyncWorker::Initialize(std::unique_ptr<SyncEngineContext> context) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(!task_manager_);
 
   context_ = std::move(context);
 
   task_manager_.reset(new SyncTaskManager(
       weak_ptr_factory_.GetWeakPtr(), 0 /* maximum_background_task */,
       context_->GetWorkerTaskRunner(),
       context_->GetWorkerPool()));
   task_manager_->Initialize(SYNC_STATUS_OK);
 
   PostInitializeTask();
 }
 
 void SyncWorker::RegisterOrigin(
     const GURL& origin,
     const SyncStatusCallback& callback) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   if (!GetMetadataDatabase())
     PostInitializeTask();
 
-  scoped_ptr<RegisterAppTask> task(
+  std::unique_ptr<RegisterAppTask> task(
       new RegisterAppTask(context_.get(), origin.host()));
   if (task->CanFinishImmediately()) {
     callback.Run(SYNC_STATUS_OK);
     return;
   }
 
   task_manager_->ScheduleSyncTask(FROM_HERE, std::move(task),
                                   SyncTaskManager::PRIORITY_HIGH, callback);
 }
 
@@ skipping 25 matching lines @@
       callback);
 }
 
 void SyncWorker::UninstallOrigin(
     const GURL& origin,
     RemoteFileSyncService::UninstallFlag flag,
     const SyncStatusCallback& callback) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   task_manager_->ScheduleSyncTask(
-      FROM_HERE,
-      scoped_ptr<SyncTask>(
-          new UninstallAppTask(context_.get(), origin.host(), flag)),
-      SyncTaskManager::PRIORITY_HIGH,
-      callback);
+      FROM_HERE, std::unique_ptr<SyncTask>(
+                     new UninstallAppTask(context_.get(), origin.host(), flag)),
+      SyncTaskManager::PRIORITY_HIGH, callback);
 }
 
 void SyncWorker::ProcessRemoteChange(const SyncFileCallback& callback) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   RemoteToLocalSyncer* syncer = new RemoteToLocalSyncer(context_.get());
   task_manager_->ScheduleSyncTask(
-      FROM_HERE,
-      scoped_ptr<SyncTask>(syncer),
+      FROM_HERE, std::unique_ptr<SyncTask>(syncer),
       SyncTaskManager::PRIORITY_MED,
       base::Bind(&SyncWorker::DidProcessRemoteChange,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 syncer,
-                 callback));
+                 weak_ptr_factory_.GetWeakPtr(), syncer, callback));
 }
 
 void SyncWorker::SetRemoteChangeProcessor(
     RemoteChangeProcessorOnWorker* remote_change_processor_on_worker) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   context_->SetRemoteChangeProcessor(remote_change_processor_on_worker);
 }
 
 RemoteServiceState SyncWorker::GetCurrentState() const {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   if (!sync_enabled_)
     return REMOTE_SERVICE_DISABLED;
   return service_state_;
 }
 
 void SyncWorker::GetOriginStatusMap(
     const RemoteFileSyncService::StatusMapCallback& callback) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   if (!GetMetadataDatabase())
     return;
 
   std::vector<std::string> app_ids;
   GetMetadataDatabase()->GetRegisteredAppIDs(&app_ids);
 
-  scoped_ptr<RemoteFileSyncService::OriginStatusMap>
-      status_map(new RemoteFileSyncService::OriginStatusMap);
+  std::unique_ptr<RemoteFileSyncService::OriginStatusMap> status_map(
+      new RemoteFileSyncService::OriginStatusMap);
   for (std::vector<std::string>::const_iterator itr = app_ids.begin();
        itr != app_ids.end(); ++itr) {
     const std::string& app_id = *itr;
     GURL origin = extensions::Extension::GetBaseURLFromExtensionId(app_id);
     (*status_map)[origin] =
         GetMetadataDatabase()->IsAppEnabled(app_id) ? "Enabled" : "Disabled";
   }
 
   callback.Run(std::move(status_map));
 }
 
-scoped_ptr<base::ListValue> SyncWorker::DumpFiles(const GURL& origin) {
+std::unique_ptr<base::ListValue> SyncWorker::DumpFiles(const GURL& origin) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   if (!GetMetadataDatabase())
-    return scoped_ptr<base::ListValue>();
+    return std::unique_ptr<base::ListValue>();
   return GetMetadataDatabase()->DumpFiles(origin.host());
 }
 
-scoped_ptr<base::ListValue> SyncWorker::DumpDatabase() {
+std::unique_ptr<base::ListValue> SyncWorker::DumpDatabase() {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   if (!GetMetadataDatabase())
-    return scoped_ptr<base::ListValue>();
+    return std::unique_ptr<base::ListValue>();
   return GetMetadataDatabase()->DumpDatabase();
 }
 
 void SyncWorker::SetSyncEnabled(bool enabled) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   if (sync_enabled_ == enabled)
     return;
 
   RemoteServiceState old_state = GetCurrentState();
@@ skipping 26 matching lines @@
 void SyncWorker::ApplyLocalChange(const FileChange& local_change,
                                   const base::FilePath& local_path,
                                   const SyncFileMetadata& local_metadata,
                                   const storage::FileSystemURL& url,
                                   const SyncStatusCallback& callback) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   LocalToRemoteSyncer* syncer = new LocalToRemoteSyncer(
       context_.get(), local_metadata, local_change, local_path, url);
   task_manager_->ScheduleSyncTask(
-      FROM_HERE,
-      scoped_ptr<SyncTask>(syncer),
+      FROM_HERE, std::unique_ptr<SyncTask>(syncer),
       SyncTaskManager::PRIORITY_MED,
       base::Bind(&SyncWorker::DidApplyLocalChange,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 syncer,
-                 callback));
+                 weak_ptr_factory_.GetWeakPtr(), syncer, callback));
 }
 
 void SyncWorker::MaybeScheduleNextTask() {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   if (GetCurrentState() == REMOTE_SERVICE_DISABLED)
     return;
 
   // TODO(tzik): Notify observer of OnRemoteChangeQueueUpdated.
   // TODO(tzik): Add an interface to get the number of dirty trackers to
@@ skipping 16 matching lines @@
 
   UpdateServiceStateFromSyncStatusCode(status, used_network);
 
   if (GetMetadataDatabase()) {
     FOR_EACH_OBSERVER(
         Observer, observers_,
         OnPendingFileListUpdated(GetMetadataDatabase()->CountDirtyTracker()));
   }
 }
 
-void SyncWorker::RecordTaskLog(scoped_ptr<TaskLogger::TaskLog> task_log) {
+void SyncWorker::RecordTaskLog(std::unique_ptr<TaskLogger::TaskLog> task_log) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   context_->GetUITaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&TaskLogger::RecordLog,
                  context_->GetTaskLogger(),
                  base::Passed(&task_log)));
 }
 
 void SyncWorker::ActivateService(RemoteServiceState service_state,
@@ skipping 54 matching lines @@
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(!GetMetadataDatabase());
 
   // This initializer task may not run if MetadataDatabase in context_ is
   // already initialized when it runs.
   SyncEngineInitializer* initializer =
       new SyncEngineInitializer(context_.get(),
                                 base_dir_.Append(kDatabaseName),
                                 env_override_);
   task_manager_->ScheduleSyncTask(
-      FROM_HERE,
-      scoped_ptr<SyncTask>(initializer),
+      FROM_HERE, std::unique_ptr<SyncTask>(initializer),
       SyncTaskManager::PRIORITY_HIGH,
-      base::Bind(&SyncWorker::DidInitialize,
-                 weak_ptr_factory_.GetWeakPtr(),
+      base::Bind(&SyncWorker::DidInitialize, weak_ptr_factory_.GetWeakPtr(),
                  initializer));
 }
 
 void SyncWorker::DidInitialize(SyncEngineInitializer* initializer,
                                SyncStatusCode status) {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
 
   if (status == SYNC_STATUS_ACCESS_FORBIDDEN) {
     UpdateServiceState(REMOTE_SERVICE_ACCESS_FORBIDDEN, "Access forbidden");
     return;
   }
   if (status != SYNC_STATUS_OK) {
     UpdateServiceState(REMOTE_SERVICE_TEMPORARY_UNAVAILABLE,
                        "Could not initialize remote service");
     return;
   }
 
-  scoped_ptr<MetadataDatabase> metadata_database =
+  std::unique_ptr<MetadataDatabase> metadata_database =
       initializer->PassMetadataDatabase();
   if (metadata_database) {
     context_->SetMetadataDatabase(std::move(metadata_database));
     return;
   }
 
   UpdateServiceState(REMOTE_SERVICE_OK, std::string());
   UpdateRegisteredApps();
 }
 
 void SyncWorker::UpdateRegisteredApps() {
   MetadataDatabase* metadata_db = GetMetadataDatabase();
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   DCHECK(metadata_db);
 
-  scoped_ptr<std::vector<std::string> > app_ids(new std::vector<std::string>);
+  std::unique_ptr<std::vector<std::string>> app_ids(
+      new std::vector<std::string>);
   metadata_db->GetRegisteredAppIDs(app_ids.get());
 
   AppStatusMap* app_status = new AppStatusMap;
   base::Closure callback =
       base::Bind(&SyncWorker::DidQueryAppStatus,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Owned(app_status));
 
   context_->GetUITaskRunner()->PostTask(
       FROM_HERE,
@@ skipping 129 matching lines @@
 
   if (status == SYNC_STATUS_UNKNOWN_ORIGIN && syncer->url().is_valid()) {
     RegisterOrigin(syncer->url().origin(),
                    base::Bind(&EmptyStatusCallback));
   }
 
   if (syncer->needs_remote_change_listing() &&
       !listing_remote_changes_) {
     task_manager_->ScheduleSyncTask(
         FROM_HERE,
-        scoped_ptr<SyncTask>(new ListChangesTask(context_.get())),
+        std::unique_ptr<SyncTask>(new ListChangesTask(context_.get())),
         SyncTaskManager::PRIORITY_HIGH,
         base::Bind(&SyncWorker::DidFetchChanges,
                    weak_ptr_factory_.GetWeakPtr()));
     should_check_remote_change_ = false;
     listing_remote_changes_ = true;
     time_to_check_changes_ =
         base::TimeTicks::Now() +
         base::TimeDelta::FromSeconds(kListChangesRetryDelaySeconds);
   }
 
@@ skipping 15 matching lines @@
   if (listing_remote_changes_)
     return false;
 
   base::TimeTicks now = base::TimeTicks::Now();
   if (!should_check_remote_change_ && now < time_to_check_changes_) {
     if (!GetMetadataDatabase()->HasDirtyTracker() &&
         should_check_conflict_) {
       should_check_conflict_ = false;
       return task_manager_->ScheduleSyncTaskIfIdle(
           FROM_HERE,
-          scoped_ptr<SyncTask>(new ConflictResolver(context_.get())),
+          std::unique_ptr<SyncTask>(new ConflictResolver(context_.get())),
           base::Bind(&SyncWorker::DidResolveConflict,
                      weak_ptr_factory_.GetWeakPtr()));
     }
     return false;
   }
 
   if (task_manager_->ScheduleSyncTaskIfIdle(
           FROM_HERE,
-          scoped_ptr<SyncTask>(new ListChangesTask(context_.get())),
+          std::unique_ptr<SyncTask>(new ListChangesTask(context_.get())),
           base::Bind(&SyncWorker::DidFetchChanges,
                      weak_ptr_factory_.GetWeakPtr()))) {
     should_check_remote_change_ = false;
     listing_remote_changes_ = true;
     time_to_check_changes_ =
         now + base::TimeDelta::FromSeconds(kListChangesRetryDelaySeconds);
     return true;
   }
   return false;
 }
@@ skipping 98 matching lines @@
   return context_->GetDriveUploader();
 }
 
 MetadataDatabase* SyncWorker::GetMetadataDatabase() {
   DCHECK(sequence_checker_.CalledOnValidSequencedThread());
   return context_->GetMetadataDatabase();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system