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

content/child/service_worker/service_worker_dispatcher.cc

 // Copyright 2013 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/service_worker/service_worker_dispatcher.h"
 
 #include <stddef.h>
+#include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_local.h"
 #include "base/trace_event/trace_event.h"
 #include "content/child/service_worker/service_worker_handle_reference.h"
 #include "content/child/service_worker/service_worker_provider_context.h"
 #include "content/child/service_worker/service_worker_registration_handle_reference.h"
@@ skipping 250 matching lines @@
     scoped_ptr<ServiceWorkerHandleReference> handle_ref) {
   if (!handle_ref)
     return nullptr;
 
   WorkerObjectMap::iterator found =
       service_workers_.find(handle_ref->handle_id());
   if (found != service_workers_.end())
     return found->second;
 
   // WebServiceWorkerImpl constructor calls AddServiceWorker.
-  return new WebServiceWorkerImpl(handle_ref.Pass(), thread_safe_sender_.get());
+  return new WebServiceWorkerImpl(std::move(handle_ref),
+                                  thread_safe_sender_.get());
 }
 
 scoped_refptr<WebServiceWorkerRegistrationImpl>
 ServiceWorkerDispatcher::GetOrCreateRegistration(
     const ServiceWorkerRegistrationObjectInfo& info,
     const ServiceWorkerVersionAttributes& attrs) {
   RegistrationObjectMap::iterator found = registrations_.find(info.handle_id);
   if (found != registrations_.end())
     return found->second;
 
@@ skipping 27 matching lines @@
   scoped_ptr<ServiceWorkerHandleReference> waiting_ref = Adopt(attrs.waiting);
   scoped_ptr<ServiceWorkerHandleReference> active_ref = Adopt(attrs.active);
 
   RegistrationObjectMap::iterator found = registrations_.find(info.handle_id);
   if (found != registrations_.end())
     return found->second;
 
   // WebServiceWorkerRegistrationImpl constructor calls
   // AddServiceWorkerRegistration.
   scoped_refptr<WebServiceWorkerRegistrationImpl> registration(
-      new WebServiceWorkerRegistrationImpl(registration_ref.Pass()));
-  registration->SetInstalling(GetOrCreateServiceWorker(installing_ref.Pass()));
-  registration->SetWaiting(GetOrCreateServiceWorker(waiting_ref.Pass()));
-  registration->SetActive(GetOrCreateServiceWorker(active_ref.Pass()));
+      new WebServiceWorkerRegistrationImpl(std::move(registration_ref)));
+  registration->SetInstalling(
+      GetOrCreateServiceWorker(std::move(installing_ref)));
+  registration->SetWaiting(GetOrCreateServiceWorker(std::move(waiting_ref)));
+  registration->SetActive(GetOrCreateServiceWorker(std::move(active_ref)));
   return registration;
 }
 
 void ServiceWorkerDispatcher::OnAssociateRegistration(
     int thread_id,
     int provider_id,
     const ServiceWorkerRegistrationObjectInfo& info,
     const ServiceWorkerVersionAttributes& attrs) {
   // Adopt the references sent from the browser process and pass them to the
   // provider context if it exists.
   scoped_ptr<ServiceWorkerRegistrationHandleReference> registration =
       Adopt(info);
   scoped_ptr<ServiceWorkerHandleReference> installing = Adopt(attrs.installing);
   scoped_ptr<ServiceWorkerHandleReference> waiting = Adopt(attrs.waiting);
   scoped_ptr<ServiceWorkerHandleReference> active = Adopt(attrs.active);
   ProviderContextMap::iterator context = provider_contexts_.find(provider_id);
   if (context != provider_contexts_.end()) {
     context->second->OnAssociateRegistration(
-        registration.Pass(), installing.Pass(), waiting.Pass(), active.Pass());
+        std::move(registration), std::move(installing), std::move(waiting),
+        std::move(active));
   }
 }
 
 void ServiceWorkerDispatcher::OnDisassociateRegistration(
     int thread_id,
     int provider_id) {
   ProviderContextMap::iterator provider = provider_contexts_.find(provider_id);
   if (provider == provider_contexts_.end())
     return;
   provider->second->OnDisassociateRegistration();
@@ skipping 291 matching lines @@
   scoped_ptr<ServiceWorkerHandleReference> installing = Adopt(attrs.installing);
   scoped_ptr<ServiceWorkerHandleReference> waiting = Adopt(attrs.waiting);
   scoped_ptr<ServiceWorkerHandleReference> active = Adopt(attrs.active);
 
   RegistrationObjectMap::iterator found =
       registrations_.find(registration_handle_id);
   if (found != registrations_.end()) {
     // Populate the version fields (eg. .installing) with worker objects.
     ChangedVersionAttributesMask mask(changed_mask);
     if (mask.installing_changed())
-      found->second->SetInstalling(GetOrCreateServiceWorker(installing.Pass()));
+      found->second->SetInstalling(
+          GetOrCreateServiceWorker(std::move(installing)));
     if (mask.waiting_changed())
-      found->second->SetWaiting(GetOrCreateServiceWorker(waiting.Pass()));
+      found->second->SetWaiting(GetOrCreateServiceWorker(std::move(waiting)));
     if (mask.active_changed())
-      found->second->SetActive(GetOrCreateServiceWorker(active.Pass()));
+      found->second->SetActive(GetOrCreateServiceWorker(std::move(active)));
   }
 }
 
 void ServiceWorkerDispatcher::OnUpdateFound(
     int thread_id,
     int registration_handle_id) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerDispatcher::OnUpdateFound");
   RegistrationObjectMap::iterator found =
       registrations_.find(registration_handle_id);
   if (found != registrations_.end())
     found->second->OnUpdateFound();
 }
 
 void ServiceWorkerDispatcher::OnSetControllerServiceWorker(
     int thread_id,
     int provider_id,
     const ServiceWorkerObjectInfo& info,
     bool should_notify_controllerchange) {
   TRACE_EVENT2("ServiceWorker",
                "ServiceWorkerDispatcher::OnSetControllerServiceWorker",
                "Thread ID", thread_id,
                "Provider ID", provider_id);
 
   // Adopt the reference sent from the browser process and pass it to the
   // provider context if it exists.
   scoped_ptr<ServiceWorkerHandleReference> handle_ref = Adopt(info);
   ProviderContextMap::iterator provider = provider_contexts_.find(provider_id);
   if (provider != provider_contexts_.end())
-    provider->second->OnSetControllerServiceWorker(handle_ref.Pass());
+    provider->second->OnSetControllerServiceWorker(std::move(handle_ref));
 
   ProviderClientMap::iterator found = provider_clients_.find(provider_id);
   if (found != provider_clients_.end()) {
     // Get the existing worker object or create a new one with a new reference
     // to populate the .controller field.
     scoped_refptr<WebServiceWorkerImpl> worker = GetOrCreateServiceWorker(
         ServiceWorkerHandleReference::Create(info, thread_safe_sender_.get()));
     found->second->setController(WebServiceWorkerImpl::CreateHandle(worker),
                                  should_notify_controllerchange);
   }
@@ skipping 59 matching lines @@
   return ServiceWorkerRegistrationHandleReference::Adopt(
       info, thread_safe_sender_.get());
 }
 
 scoped_ptr<ServiceWorkerHandleReference> ServiceWorkerDispatcher::Adopt(
     const ServiceWorkerObjectInfo& info) {
   return ServiceWorkerHandleReference::Adopt(info, thread_safe_sender_.get());
 }
 
 }  // namespace content