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

content/browser/service_worker/embedded_worker_instance.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/browser/service_worker/embedded_worker_instance.h"
 
+#include <utility>
+
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/devtools/service_worker_devtools_manager.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/common/content_switches_internal.h"
 #include "content/common/mojo/service_registry_impl.h"
@@ skipping 62 matching lines @@
     int process_id,
     int thread_id,
     mojo::InterfaceRequest<mojo::ServiceProvider> services,
     mojo::InterfacePtrInfo<mojo::ServiceProvider> exposed_services) {
   RenderProcessHost* rph = RenderProcessHost::FromID(process_id);
   // |rph| or its ServiceRegistry may be NULL in unit tests.
   if (!rph || !rph->GetServiceRegistry())
     return;
   EmbeddedWorkerSetupPtr setup;
   rph->GetServiceRegistry()->ConnectToRemoteService(mojo::GetProxy(&setup));
-  setup->ExchangeServiceProviders(thread_id, services.Pass(),
-                                  mojo::MakeProxy(exposed_services.Pass()));
+  setup->ExchangeServiceProviders(thread_id, std::move(services),
+                                  mojo::MakeProxy(std::move(exposed_services)));
 }
 
 }  // namespace
 
 // Lives on IO thread, proxies notifications to DevToolsManager that lives on
 // UI thread. Owned by EmbeddedWorkerInstance.
 class EmbeddedWorkerInstance::DevToolsProxy : public base::NonThreadSafe {
  public:
   DevToolsProxy(int process_id, int agent_route_id)
       : process_id_(process_id),
@@ skipping 155 matching lines @@
   }
   if (!instance) {
     if (status == SERVICE_WORKER_OK) {
       // We only have a process allocated if the status is OK.
       context->process_manager()->ReleaseWorkerProcess(
           params->embedded_worker_id);
     }
     callback.Run(SERVICE_WORKER_ERROR_ABORT);
     return;
   }
-  instance->ProcessAllocated(params.Pass(), callback, process_id,
+  instance->ProcessAllocated(std::move(params), callback, process_id,
                              is_new_process, status);
 }
 
 void EmbeddedWorkerInstance::ProcessAllocated(
     scoped_ptr<EmbeddedWorkerMsg_StartWorker_Params> params,
     const StatusCallback& callback,
     int process_id,
     bool is_new_process,
     ServiceWorkerStatusCode status) {
   DCHECK_EQ(process_id_, -1);
@@ skipping 58 matching lines @@
     }
     UMA_HISTOGRAM_BOOLEAN("EmbeddedWorkerInstance.ProcessCreated",
                           is_new_process);
     // Reset |start_timing_| to measure the time excluding the process
     // allocation time.
     start_timing_ = base::TimeTicks::Now();
   }
 
   starting_phase_ = SENT_START_WORKER;
   ServiceWorkerStatusCode status =
-      registry_->SendStartWorker(params.Pass(), process_id_);
+      registry_->SendStartWorker(std::move(params), process_id_);
   if (status != SERVICE_WORKER_OK) {
     OnStartFailed(callback, status);
     return;
   }
   DCHECK(start_callback_.is_null());
   start_callback_ = callback;
 }
 
 void EmbeddedWorkerInstance::OnReadyForInspection() {
   if (devtools_proxy_)
@@ skipping 34 matching lines @@
   mojo::ServiceProviderPtr exposed_services;
   service_registry_->Bind(GetProxy(&exposed_services));
   mojo::ServiceProviderPtr services;
   mojo::InterfaceRequest<mojo::ServiceProvider> services_request =
       GetProxy(&services);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(SetupMojoOnUIThread, process_id_, thread_id_,
                  base::Passed(&services_request),
                  base::Passed(exposed_services.PassInterface())));
-  service_registry_->BindRemoteServiceProvider(services.Pass());
+  service_registry_->BindRemoteServiceProvider(std::move(services));
 }
 
 void EmbeddedWorkerInstance::OnScriptLoadFailed() {
   FOR_EACH_OBSERVER(Listener, listener_list_, OnScriptLoadFailed());
 }
 
 void EmbeddedWorkerInstance::OnScriptEvaluated(bool success) {
   starting_phase_ = SCRIPT_EVALUATED;
   if (start_callback_.is_null()) {
     DVLOG(1) << "Received unexpected OnScriptEvaluated message.";
@@ skipping 155 matching lines @@
     case SCRIPT_READ_FINISHED:
       return "Script read finished";
     case STARTING_PHASE_MAX_VALUE:
       NOTREACHED();
   }
   NOTREACHED() << phase;
   return std::string();
 }
 
 }  // namespace content