Convert //content/browser from scoped_ptr to std::unique_ptr

content/browser/background_sync/background_sync_manager.cc

 // Copyright 2015 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 "content/browser/background_sync/background_sync_manager.h"
 
 #include <utility>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/default_clock.h"
 #include "build/build_config.h"
 #include "content/browser/background_sync/background_sync_metrics.h"
 #include "content/browser/background_sync/background_sync_network_observer.h"
 #include "content/browser/background_sync/background_sync_registration_options.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_storage.h"
 #include "content/browser/storage_partition_impl.h"
@@ skipping 17 matching lines @@
 const char kBackgroundSyncUserDataKey[] = "BackgroundSyncUserData";
 
 void RecordFailureAndPostError(
     BackgroundSyncStatus status,
     const BackgroundSyncManager::StatusAndRegistrationCallback& callback) {
   BackgroundSyncMetrics::CountRegisterFailure(status);
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, status,
-                 base::Passed(scoped_ptr<BackgroundSyncRegistration>())));
+                 base::Passed(std::unique_ptr<BackgroundSyncRegistration>())));
 }
 
 // Returns nullptr if the browser context cannot be accessed for any reason.
 BrowserContext* GetBrowserContextOnUIThread(
     const scoped_refptr<ServiceWorkerContextWrapper>& service_worker_context) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!service_worker_context)
     return nullptr;
   StoragePartitionImpl* storage_partition_impl =
@@ skipping 59 matching lines @@
     int64_t min_ms) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BackgroundSyncController* background_sync_controller =
       GetBackgroundSyncControllerOnUIThread(sw_context_wrapper);
   if (background_sync_controller) {
     background_sync_controller->RunInBackground(enabled, min_ms);
   }
 }
 
-scoped_ptr<BackgroundSyncParameters> GetControllerParameters(
+std::unique_ptr<BackgroundSyncParameters> GetControllerParameters(
     const scoped_refptr<ServiceWorkerContextWrapper>& sw_context_wrapper,
-    scoped_ptr<BackgroundSyncParameters> parameters) {
+    std::unique_ptr<BackgroundSyncParameters> parameters) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BackgroundSyncController* background_sync_controller =
       GetBackgroundSyncControllerOnUIThread(sw_context_wrapper);
 
   if (!background_sync_controller) {
     // If there is no controller then BackgroundSync can't run in the
     // background, disable it.
     parameters->disable = true;
     return parameters;
@@ skipping 24 matching lines @@
 }
 
 BackgroundSyncManager::BackgroundSyncRegistrations::BackgroundSyncRegistrations(
     const BackgroundSyncRegistrations& other) = default;
 
 BackgroundSyncManager::BackgroundSyncRegistrations::
     ~BackgroundSyncRegistrations() {
 }
 
 // static
-scoped_ptr<BackgroundSyncManager> BackgroundSyncManager::Create(
+std::unique_ptr<BackgroundSyncManager> BackgroundSyncManager::Create(
     const scoped_refptr<ServiceWorkerContextWrapper>& service_worker_context) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   BackgroundSyncManager* sync_manager =
       new BackgroundSyncManager(service_worker_context);
   sync_manager->Init();
-  return make_scoped_ptr(sync_manager);
+  return base::WrapUnique(sync_manager);
 }
 
 BackgroundSyncManager::~BackgroundSyncManager() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   service_worker_context_->RemoveObserver(this);
 }
 
 void BackgroundSyncManager::Register(
     int64_t sw_registration_id,
@@ skipping 15 matching lines @@
 void BackgroundSyncManager::GetRegistrations(
     int64_t sw_registration_id,
     const StatusAndRegistrationsCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (disabled_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(
             callback, BACKGROUND_SYNC_STATUS_STORAGE_ERROR,
-            base::Passed(scoped_ptr<ScopedVector<BackgroundSyncRegistration>>(
-                new ScopedVector<BackgroundSyncRegistration>()))));
+            base::Passed(
+                std::unique_ptr<ScopedVector<BackgroundSyncRegistration>>(
+                    new ScopedVector<BackgroundSyncRegistration>()))));
     return;
   }
 
   op_scheduler_.ScheduleOperation(
       base::Bind(&BackgroundSyncManager::GetRegistrationsImpl,
                  weak_ptr_factory_.GetWeakPtr(), sw_registration_id,
                  MakeStatusAndRegistrationsCompletion(callback)));
 }
 
 void BackgroundSyncManager::OnRegistrationDeleted(int64_t sw_registration_id,
@@ skipping 62 matching lines @@
 
 void BackgroundSyncManager::InitImpl(const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (disabled_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback));
     return;
   }
 
-  scoped_ptr<BackgroundSyncParameters> parameters_copy(
+  std::unique_ptr<BackgroundSyncParameters> parameters_copy(
       new BackgroundSyncParameters(*parameters_));
 
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&GetControllerParameters, service_worker_context_,
                  base::Passed(std::move(parameters_copy))),
       base::Bind(&BackgroundSyncManager::InitDidGetControllerParameters,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void BackgroundSyncManager::InitDidGetControllerParameters(
     const base::Closure& callback,
-    scoped_ptr<BackgroundSyncParameters> updated_parameters) {
+    std::unique_ptr<BackgroundSyncParameters> updated_parameters) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   parameters_ = std::move(updated_parameters);
   if (parameters_->disable) {
     disabled_ = true;
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback));
     return;
   }
 
@@ skipping 175 matching lines @@
         BackgroundSyncMetrics::REGISTRATION_IS_DUPLICATE);
 
     if (existing_registration->IsFiring()) {
       existing_registration->set_sync_state(
           mojom::BackgroundSyncState::REREGISTERED_WHILE_FIRING);
     }
 
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, BACKGROUND_SYNC_STATUS_OK,
-                   base::Passed(make_scoped_ptr(new BackgroundSyncRegistration(
+                   base::Passed(base::WrapUnique(new BackgroundSyncRegistration(
                        *existing_registration)))));
     return;
   }
 
   BackgroundSyncRegistration new_registration;
 
   *new_registration.options() = options;
 
   BackgroundSyncRegistrations* registrations =
       &active_registrations_[sw_registration_id];
@@ skipping 132 matching lines @@
     active_registrations_.erase(sw_registration_id);
     RecordFailureAndPostError(BACKGROUND_SYNC_STATUS_STORAGE_ERROR, callback);
     return;
   }
 
   if (status != SERVICE_WORKER_OK) {
     LOG(ERROR) << "BackgroundSync failed to store registration due to backend "
                   "failure.";
     BackgroundSyncMetrics::CountRegisterFailure(
         BACKGROUND_SYNC_STATUS_STORAGE_ERROR);
-    DisableAndClearManager(
-        base::Bind(callback, BACKGROUND_SYNC_STATUS_STORAGE_ERROR,
-                   base::Passed(scoped_ptr<BackgroundSyncRegistration>())));
+    DisableAndClearManager(base::Bind(
+        callback, BACKGROUND_SYNC_STATUS_STORAGE_ERROR,
+        base::Passed(std::unique_ptr<BackgroundSyncRegistration>())));
     return;
   }
 
   BackgroundSyncMetrics::RegistrationCouldFire registration_could_fire =
       AreOptionConditionsMet(*new_registration.options())
           ? BackgroundSyncMetrics::REGISTRATION_COULD_FIRE
           : BackgroundSyncMetrics::REGISTRATION_COULD_NOT_FIRE;
   BackgroundSyncMetrics::CountRegisterSuccess(
       registration_could_fire,
       BackgroundSyncMetrics::REGISTRATION_IS_NOT_DUPLICATE);
 
   FireReadyEvents();
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, BACKGROUND_SYNC_STATUS_OK,
-                 base::Passed(make_scoped_ptr(
+                 base::Passed(base::WrapUnique(
                      new BackgroundSyncRegistration(new_registration)))));
 }
 
 void BackgroundSyncManager::RemoveActiveRegistration(int64_t sw_registration_id,
                                                      const std::string& tag) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(LookupActiveRegistration(sw_registration_id, tag));
 
   BackgroundSyncRegistrations* registrations =
       &active_registrations_[sw_registration_id];
@@ skipping 80 matching lines @@
     const GURL& origin,
     const BoolCallback& callback) {
   service_worker_context_->HasMainFrameProviderHost(origin, callback);
 }
 
 void BackgroundSyncManager::GetRegistrationsImpl(
     int64_t sw_registration_id,
     const StatusAndRegistrationsCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  scoped_ptr<ScopedVector<BackgroundSyncRegistration>> out_registrations(
+  std::unique_ptr<ScopedVector<BackgroundSyncRegistration>> out_registrations(
       new ScopedVector<BackgroundSyncRegistration>());
 
   if (disabled_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, BACKGROUND_SYNC_STATUS_STORAGE_ERROR,
                               base::Passed(std::move(out_registrations))));
     return;
   }
 
   SWIdToRegistrationsMap::iterator it =
@@ skipping 382 matching lines @@
                                                       Params... parameters) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   callback.Run(parameters...);
   op_scheduler_.CompleteOperationAndRunNext();
 }
 
 void BackgroundSyncManager::CompleteStatusAndRegistrationCallback(
     StatusAndRegistrationCallback callback,
     BackgroundSyncStatus status,
-    scoped_ptr<BackgroundSyncRegistration> registration) {
+    std::unique_ptr<BackgroundSyncRegistration> registration) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   callback.Run(status, std::move(registration));
   op_scheduler_.CompleteOperationAndRunNext();
 }
 
 void BackgroundSyncManager::CompleteStatusAndRegistrationsCallback(
     StatusAndRegistrationsCallback callback,
     BackgroundSyncStatus status,
-    scoped_ptr<ScopedVector<BackgroundSyncRegistration>> registrations) {
+    std::unique_ptr<ScopedVector<BackgroundSyncRegistration>> registrations) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   callback.Run(status, std::move(registrations));
   op_scheduler_.CompleteOperationAndRunNext();
 }
 
 base::Closure BackgroundSyncManager::MakeEmptyCompletion() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   return MakeClosureCompletion(base::Bind(base::DoNothing));
@@ skipping 32 matching lines @@
 BackgroundSyncManager::MakeStatusCompletion(const StatusCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   return base::Bind(
       &BackgroundSyncManager::CompleteOperationCallback<StatusCallback,
                                                         BackgroundSyncStatus>,
       weak_ptr_factory_.GetWeakPtr(), callback);
 }
 
 }  // namespace content