Convert Pass()→std::move() in //content/browser

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/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_power_observer.h"
@@ skipping 32 matching lines @@
 const char kBackgroundSyncUserDataKey[] = "BackgroundSyncUserData";
 
 // The amount of time that a sync event can fire for, in seconds.
 const int kSyncEventSec = 3 * 60;  // 3 minutes
 
 void PostErrorResponse(
     BackgroundSyncStatus status,
     const BackgroundSyncManager::StatusAndRegistrationCallback& callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
-      base::Bind(
-          callback, status,
-          base::Passed(scoped_ptr<BackgroundSyncRegistrationHandle>().Pass())));
+      base::Bind(callback, status,
+                 base::Passed(scoped_ptr<BackgroundSyncRegistrationHandle>())));
 }
 
 // Returns nullptr if the controller cannot be accessed for any reason.
 BackgroundSyncController* GetBackgroundSyncControllerOnUIThread(
     const scoped_refptr<ServiceWorkerContextWrapper>& service_worker_context) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!service_worker_context)
     return nullptr;
   StoragePartitionImpl* storage_partition_impl =
@@ skipping 35 matching lines @@
 scoped_ptr<BackgroundSyncParameters> GetControllerParameters(
     const scoped_refptr<ServiceWorkerContextWrapper>& sw_context_wrapper,
     scoped_ptr<BackgroundSyncParameters> parameters) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BackgroundSyncController* background_sync_controller =
       GetBackgroundSyncControllerOnUIThread(sw_context_wrapper);
 
   if (!background_sync_controller) {
     // Return default ParameterOverrides which don't disable and don't override.
-    return parameters.Pass();
+    return parameters;
   }
 
   background_sync_controller->GetParameterOverrides(parameters.get());
-  return parameters.Pass();
+  return parameters;
 }
 
 }  // namespace
 
 BackgroundSyncManager::BackgroundSyncRegistrations::
     BackgroundSyncRegistrations()
     : next_id(BackgroundSyncRegistration::kInitialId) {
 }
 
 BackgroundSyncManager::BackgroundSyncRegistrations::
@@ skipping 88 matching lines @@
     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<BackgroundSyncRegistrationHandle>>(
-                    new ScopedVector<BackgroundSyncRegistrationHandle>())
-                    .Pass())));
+                    new ScopedVector<BackgroundSyncRegistrationHandle>()))));
     return;
   }
 
   op_scheduler_.ScheduleOperation(
       base::Bind(&BackgroundSyncManager::GetRegistrationsImpl,
                  weak_ptr_factory_.GetWeakPtr(), sw_registration_id,
                  periodicity, MakeStatusAndRegistrationsCompletion(callback)));
 }
 
 // Given a HandleId |handle_id|, return a new handle for the same
@@ skipping 77 matching lines @@
                                                   base::Bind(callback));
     return;
   }
 
   scoped_ptr<BackgroundSyncParameters> parameters_copy(
       new BackgroundSyncParameters(*parameters_));
 
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&GetControllerParameters, service_worker_context_,
-                 base::Passed(parameters_copy.Pass())),
+                 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) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  parameters_ = updated_parameters.Pass();
+  parameters_ = std::move(updated_parameters);
   if (parameters_->disable) {
     disabled_ = true;
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback));
     return;
   }
 
   GetDataFromBackend(
       kBackgroundSyncUserDataKey,
       base::Bind(&BackgroundSyncManager::InitDidGetDataFromBackend,
@@ skipping 159 matching lines @@
 
     if (existing_registration->IsFiring()) {
       existing_registration->set_sync_state(
           BACKGROUND_SYNC_STATE_REREGISTERED_WHILE_FIRING);
     }
 
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(
             callback, BACKGROUND_SYNC_STATUS_OK,
-            base::Passed(
-                CreateRegistrationHandle(existing_registration_ref).Pass())));
+            base::Passed(CreateRegistrationHandle(existing_registration_ref))));
     return;
     } else {
       existing_registration_ref->value()->SetUnregisteredState();
     }
   }
 
   scoped_refptr<RefCountedRegistration> new_ref_registration(
       new RefCountedRegistration());
   BackgroundSyncRegistration* new_registration = new_ref_registration->value();
 
@@ skipping 159 matching lines @@
   }
 
   if (status != SERVICE_WORKER_OK) {
     LOG(ERROR) << "BackgroundSync failed to store registration due to backend "
                   "failure.";
     BackgroundSyncMetrics::CountRegisterFailure(
         new_registration->options()->periodicity,
         BACKGROUND_SYNC_STATUS_STORAGE_ERROR);
     DisableAndClearManager(base::Bind(
         callback, BACKGROUND_SYNC_STATUS_STORAGE_ERROR,
-        base::Passed(scoped_ptr<BackgroundSyncRegistrationHandle>().Pass())));
+        base::Passed(scoped_ptr<BackgroundSyncRegistrationHandle>())));
     return;
   }
 
   BackgroundSyncMetrics::RegistrationCouldFire registration_could_fire =
       AreOptionConditionsMet(*new_registration->options())
           ? BackgroundSyncMetrics::REGISTRATION_COULD_FIRE
           : BackgroundSyncMetrics::REGISTRATION_COULD_NOT_FIRE;
   BackgroundSyncMetrics::CountRegisterSuccess(
       new_registration->options()->periodicity, registration_could_fire,
       BackgroundSyncMetrics::REGISTRATION_IS_NOT_DUPLICATE);
 
   FireReadyEvents();
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(
           callback, BACKGROUND_SYNC_STATUS_OK,
-          base::Passed(
-              CreateRegistrationHandle(new_registration_ref.get()).Pass())));
+          base::Passed(CreateRegistrationHandle(new_registration_ref.get()))));
 }
 
 void BackgroundSyncManager::RemoveActiveRegistration(
     int64_t sw_registration_id,
     const RegistrationKey& registration_key) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(LookupActiveRegistration(sw_registration_id, registration_key));
 
   BackgroundSyncRegistrations* registrations =
       &active_registrations_[sw_registration_id];
@@ skipping 205 matching lines @@
                               BACKGROUND_SYNC_STATE_FAILED));
     return;
   }
 
   scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle =
       DuplicateRegistrationHandle(handle_id);
 
   op_scheduler_.ScheduleOperation(
       base::Bind(&BackgroundSyncManager::NotifyWhenFinishedImpl,
                  weak_ptr_factory_.GetWeakPtr(),
-                 base::Passed(registration_handle.Pass()), callback));
+                 base::Passed(std::move(registration_handle)), callback));
 }
 
 void BackgroundSyncManager::NotifyWhenFinishedImpl(
     scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle,
     const StatusAndStateCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_EQ(SYNC_ONE_SHOT, registration_handle->options()->periodicity);
 
   if (disabled_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ skipping 38 matching lines @@
   RefCountedRegistration* registration =
       LookupActiveRegistration(sw_registration_id, registration_key);
   if (!registration) {
     PostErrorResponse(BACKGROUND_SYNC_STATUS_NOT_FOUND, callback);
     return;
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(callback, BACKGROUND_SYNC_STATUS_OK,
-                 base::Passed(CreateRegistrationHandle(registration).Pass())));
+                 base::Passed(CreateRegistrationHandle(registration))));
 }
 
 void BackgroundSyncManager::GetRegistrationsImpl(
     int64_t sw_registration_id,
     SyncPeriodicity periodicity,
     const StatusAndRegistrationsCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   scoped_ptr<ScopedVector<BackgroundSyncRegistrationHandle>> out_registrations(
       new ScopedVector<BackgroundSyncRegistrationHandle>());
 
   if (disabled_) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, BACKGROUND_SYNC_STATUS_STORAGE_ERROR,
-                              base::Passed(out_registrations.Pass())));
+                              base::Passed(std::move(out_registrations))));
     return;
   }
 
   SWIdToRegistrationsMap::iterator it =
       active_registrations_.find(sw_registration_id);
 
   if (it != active_registrations_.end()) {
     const BackgroundSyncRegistrations& registrations = it->second;
     for (const auto& tag_and_registration : registrations.registration_map) {
       RefCountedRegistration* registration = tag_and_registration.second.get();
       if (registration->value()->options()->periodicity == periodicity) {
         out_registrations->push_back(
             CreateRegistrationHandle(registration).release());
       }
     }
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, BACKGROUND_SYNC_STATUS_OK,
-                            base::Passed(out_registrations.Pass())));
+                            base::Passed(std::move(out_registrations))));
 }
 
 bool BackgroundSyncManager::AreOptionConditionsMet(
     const BackgroundSyncRegistrationOptions& options) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return network_observer_->NetworkSufficient(options.network_state) &&
          power_observer_->PowerSufficient(options.power_state);
 }
 
 bool BackgroundSyncManager::IsRegistrationReadyToFire(
@@ skipping 181 matching lines @@
           ? BACKGROUND_SYNC_EVENT_LAST_CHANCE_IS_LAST_CHANCE
           : BACKGROUND_SYNC_EVENT_LAST_CHANCE_IS_NOT_LAST_CHANCE;
 
   HasMainFrameProviderHost(
       service_worker_registration->pattern().GetOrigin(),
       base::Bind(&BackgroundSyncMetrics::RecordEventStarted,
                  registration->value()->options()->periodicity));
 
   FireOneShotSync(
       handle_id, service_worker_registration->active_version(), last_chance,
-      base::Bind(
-          &BackgroundSyncManager::EventComplete, weak_ptr_factory_.GetWeakPtr(),
-          service_worker_registration, service_worker_registration->id(),
-          base::Passed(registration_handle.Pass()), event_completed_callback));
+      base::Bind(&BackgroundSyncManager::EventComplete,
+                 weak_ptr_factory_.GetWeakPtr(), service_worker_registration,
+                 service_worker_registration->id(),
+                 base::Passed(std::move(registration_handle)),
+                 event_completed_callback));
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(event_fired_callback));
 }
 
 void BackgroundSyncManager::FireReadyEventsAllEventsFiring(
     const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   RunInBackgroundIfNecessary();
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                 base::Bind(callback));
 }
 
 // |service_worker_registration| is just to keep the registration alive
 // while the event is firing.
 void BackgroundSyncManager::EventComplete(
     const scoped_refptr<ServiceWorkerRegistration>& service_worker_registration,
     int64_t service_worker_id,
     scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle,
     const base::Closure& callback,
     ServiceWorkerStatusCode status_code) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Do not check for disabled as events that were firing when disabled should
   // be allowed to complete (for NotifyWhenFinished).
   op_scheduler_.ScheduleOperation(base::Bind(
       &BackgroundSyncManager::EventCompleteImpl, weak_ptr_factory_.GetWeakPtr(),
-      service_worker_id, base::Passed(registration_handle.Pass()), status_code,
-      MakeClosureCompletion(callback)));
+      service_worker_id, base::Passed(std::move(registration_handle)),
+      status_code, MakeClosureCompletion(callback)));
 }
 
 void BackgroundSyncManager::EventCompleteImpl(
     int64_t service_worker_id,
     scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle,
     ServiceWorkerStatusCode status_code,
     const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   BackgroundSyncRegistration* registration =
@@ skipping 151 matching lines @@
   callback.Run(parameters...);
   op_scheduler_.CompleteOperationAndRunNext();
 }
 
 void BackgroundSyncManager::CompleteStatusAndRegistrationCallback(
     StatusAndRegistrationCallback callback,
     BackgroundSyncStatus status,
     scoped_ptr<BackgroundSyncRegistrationHandle> registration_handle) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  callback.Run(status, registration_handle.Pass());
+  callback.Run(status, std::move(registration_handle));
   op_scheduler_.CompleteOperationAndRunNext();
 }
 
 void BackgroundSyncManager::CompleteStatusAndRegistrationsCallback(
     StatusAndRegistrationsCallback callback,
     BackgroundSyncStatus status,
     scoped_ptr<ScopedVector<BackgroundSyncRegistrationHandle>>
         registration_handles) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  callback.Run(status, registration_handles.Pass());
+  callback.Run(status, std::move(registration_handles));
   op_scheduler_.CompleteOperationAndRunNext();
 }
 
 base::Closure BackgroundSyncManager::MakeEmptyCompletion() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   return MakeClosureCompletion(base::Bind(base::DoNothing));
 }
 
 base::Closure BackgroundSyncManager::MakeClosureCompletion(
@@ skipping 29 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