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

content/child/background_sync/background_sync_provider.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/child/background_sync/background_sync_provider.h"
 
 #include <stddef.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_local.h"
 #include "content/child/background_sync/background_sync_type_converters.h"
 #include "content/child/child_thread_impl.h"
 #include "content/child/service_worker/web_service_worker_registration_impl.h"
 #include "content/public/common/background_sync.mojom.h"
@@ skipping 12 matching lines @@
 int64_t GetServiceWorkerRegistrationId(
     blink::WebServiceWorkerRegistration* service_worker_registration) {
   return static_cast<WebServiceWorkerRegistrationImpl*>(
              service_worker_registration)->registration_id();
 }
 
 void ConnectToServiceOnMainThread(
     mojo::InterfaceRequest<BackgroundSyncService> request) {
   DCHECK(ChildThreadImpl::current());
   ChildThreadImpl::current()->service_registry()->ConnectToRemoteService(
-      request.Pass());
+      std::move(request));
 }
 
 LazyInstance<ThreadLocalPointer<BackgroundSyncProvider>>::Leaky
     g_sync_provider_tls = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 BackgroundSyncProvider::BackgroundSyncProvider(
     const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner)
     : main_thread_task_runner_(main_task_runner) {
@@ skipping 44 matching lines @@
       GetServiceWorkerRegistrationId(service_worker_registration);
   scoped_ptr<const blink::WebSyncRegistration> optionsPtr(options);
   scoped_ptr<blink::WebSyncRegistrationCallbacks> callbacksPtr(callbacks);
 
   // base::Unretained is safe here, as the mojo channel will be deleted (and
   // will wipe its callbacks) before 'this' is deleted.
   GetBackgroundSyncServicePtr()->Register(
       mojo::ConvertTo<SyncRegistrationPtr>(*(optionsPtr.get())),
       service_worker_registration_id, requested_from_service_worker,
       base::Bind(&BackgroundSyncProvider::RegisterCallback,
-                 base::Unretained(this), base::Passed(callbacksPtr.Pass())));
+                 base::Unretained(this),
+                 base::Passed(std::move(callbacksPtr))));
 }
 
 void BackgroundSyncProvider::unregisterBackgroundSync(
     int64_t handle_id,
     blink::WebServiceWorkerRegistration* service_worker_registration,
     blink::WebSyncUnregistrationCallbacks* callbacks) {
   DCHECK(service_worker_registration);
   DCHECK(callbacks);
   int64_t service_worker_registration_id =
       GetServiceWorkerRegistrationId(service_worker_registration);
   scoped_ptr<blink::WebSyncUnregistrationCallbacks> callbacksPtr(callbacks);
 
   // base::Unretained is safe here, as the mojo channel will be deleted (and
   // will wipe its callbacks) before 'this' is deleted.
   GetBackgroundSyncServicePtr()->Unregister(
       handle_id, service_worker_registration_id,
       base::Bind(&BackgroundSyncProvider::UnregisterCallback,
-                 base::Unretained(this), base::Passed(callbacksPtr.Pass())));
+                 base::Unretained(this),
+                 base::Passed(std::move(callbacksPtr))));
 }
 
 void BackgroundSyncProvider::getRegistration(
     blink::WebSyncRegistration::Periodicity periodicity,
     const blink::WebString& tag,
     blink::WebServiceWorkerRegistration* service_worker_registration,
     blink::WebSyncRegistrationCallbacks* callbacks) {
   DCHECK(service_worker_registration);
   DCHECK(callbacks);
   int64_t service_worker_registration_id =
       GetServiceWorkerRegistrationId(service_worker_registration);
   scoped_ptr<blink::WebSyncRegistrationCallbacks> callbacksPtr(callbacks);
 
   // base::Unretained is safe here, as the mojo channel will be deleted (and
   // will wipe its callbacks) before 'this' is deleted.
   GetBackgroundSyncServicePtr()->GetRegistration(
       mojo::ConvertTo<BackgroundSyncPeriodicity>(periodicity), tag.utf8(),
       service_worker_registration_id,
       base::Bind(&BackgroundSyncProvider::GetRegistrationCallback,
-                 base::Unretained(this), base::Passed(callbacksPtr.Pass())));
+                 base::Unretained(this),
+                 base::Passed(std::move(callbacksPtr))));
 }
 
 void BackgroundSyncProvider::getRegistrations(
     blink::WebSyncRegistration::Periodicity periodicity,
     blink::WebServiceWorkerRegistration* service_worker_registration,
     blink::WebSyncGetRegistrationsCallbacks* callbacks) {
   DCHECK(service_worker_registration);
   DCHECK(callbacks);
   int64_t service_worker_registration_id =
       GetServiceWorkerRegistrationId(service_worker_registration);
   scoped_ptr<blink::WebSyncGetRegistrationsCallbacks> callbacksPtr(callbacks);
 
   // base::Unretained is safe here, as the mojo channel will be deleted (and
   // will wipe its callbacks) before 'this' is deleted.
   GetBackgroundSyncServicePtr()->GetRegistrations(
       mojo::ConvertTo<BackgroundSyncPeriodicity>(periodicity),
       service_worker_registration_id,
       base::Bind(&BackgroundSyncProvider::GetRegistrationsCallback,
-                 base::Unretained(this), base::Passed(callbacksPtr.Pass())));
+                 base::Unretained(this),
+                 base::Passed(std::move(callbacksPtr))));
 }
 
 void BackgroundSyncProvider::getPermissionStatus(
     blink::WebSyncRegistration::Periodicity periodicity,
     blink::WebServiceWorkerRegistration* service_worker_registration,
     blink::WebSyncGetPermissionStatusCallbacks* callbacks) {
   DCHECK(service_worker_registration);
   DCHECK(callbacks);
   int64_t service_worker_registration_id =
       GetServiceWorkerRegistrationId(service_worker_registration);
   scoped_ptr<blink::WebSyncGetPermissionStatusCallbacks> callbacksPtr(
       callbacks);
 
   // base::Unretained is safe here, as the mojo channel will be deleted (and
   // will wipe its callbacks) before 'this' is deleted.
   GetBackgroundSyncServicePtr()->GetPermissionStatus(
       mojo::ConvertTo<BackgroundSyncPeriodicity>(periodicity),
       service_worker_registration_id,
       base::Bind(&BackgroundSyncProvider::GetPermissionStatusCallback,
-                 base::Unretained(this), base::Passed(callbacksPtr.Pass())));
+                 base::Unretained(this),
+                 base::Passed(std::move(callbacksPtr))));
 }
 
 void BackgroundSyncProvider::releaseRegistration(int64_t handle_id) {
   GetBackgroundSyncServicePtr()->ReleaseRegistration(handle_id);
 }
 
 void BackgroundSyncProvider::notifyWhenFinished(
     int64_t handle_id,
     blink::WebSyncNotifyWhenFinishedCallbacks* callbacks) {
   DCHECK(callbacks);
 
   scoped_ptr<blink::WebSyncNotifyWhenFinishedCallbacks> callbacks_ptr(
       callbacks);
 
   // base::Unretained is safe here, as the mojo channel will be deleted (and
   // will wipe its callbacks) before 'this' is deleted.
   GetBackgroundSyncServicePtr()->NotifyWhenFinished(
-      handle_id,
-      base::Bind(&BackgroundSyncProvider::NotifyWhenFinishedCallback,
-                 base::Unretained(this), base::Passed(callbacks_ptr.Pass())));
+      handle_id, base::Bind(&BackgroundSyncProvider::NotifyWhenFinishedCallback,
+                            base::Unretained(this),
+                            base::Passed(std::move(callbacks_ptr))));
 }
 
 void BackgroundSyncProvider::DuplicateRegistrationHandle(
     int64_t handle_id,
     const BackgroundSyncService::DuplicateRegistrationHandleCallback&
         callback) {
   GetBackgroundSyncServicePtr()->DuplicateRegistrationHandle(handle_id,
                                                              callback);
 }
 
@@ skipping 220 matching lines @@
     mojo::InterfaceRequest<BackgroundSyncService> request =
         mojo::GetProxy(&background_sync_service_);
     main_thread_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&ConnectToServiceOnMainThread, base::Passed(&request)));
   }
   return background_sync_service_;
 }
 
 }  // namespace content