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

content/browser/shared_worker/shared_worker_service_impl.cc

 // Copyright 2014 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/shared_worker/shared_worker_service_impl.h"
 
 #include <stddef.h>
-
 #include <algorithm>
 #include <iterator>
 #include <set>
+#include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "content/browser/devtools/shared_worker_devtools_manager.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/shared_worker/shared_worker_host.h"
 #include "content/browser/shared_worker/shared_worker_instance.h"
 #include "content/browser/shared_worker/shared_worker_message_filter.h"
@@ skipping 101 matching lines @@
     const int route_id;
     const unsigned long long document_id;
     const int render_process_id;
     const int render_frame_route_id;
   };
 
   typedef ScopedVector<SharedWorkerPendingRequest> SharedWorkerPendingRequests;
 
   explicit SharedWorkerPendingInstance(
       scoped_ptr<SharedWorkerInstance> instance)
-      : instance_(instance.Pass()) {}
+      : instance_(std::move(instance)) {}
   ~SharedWorkerPendingInstance() {}
   SharedWorkerInstance* instance() { return instance_.get(); }
   SharedWorkerInstance* release_instance() { return instance_.release(); }
   SharedWorkerPendingRequests* requests() { return &requests_; }
   SharedWorkerMessageFilter* FindFilter(int process_id) {
     for (size_t i = 0; i < requests_.size(); ++i) {
       if (requests_[i]->render_process_id == process_id)
         return requests_[i]->filter;
     }
     return NULL;
@@ skipping 160 matching lines @@
   if (SharedWorkerPendingInstance* pending = FindPendingInstance(*instance)) {
     if (params.url != pending->instance()->url()) {
       *creation_error = blink::WebWorkerCreationErrorURLMismatch;
       return;
     }
     if (params.creation_context_type !=
         pending->instance()->creation_context_type()) {
       *creation_error = blink::WebWorkerCreationErrorSecureContextMismatch;
       return;
     }
-    pending->AddRequest(request.Pass());
+    pending->AddRequest(std::move(request));
     return;
   }
   scoped_ptr<SharedWorkerPendingInstance> pending_instance(
-      new SharedWorkerPendingInstance(instance.Pass()));
-  pending_instance->AddRequest(request.Pass());
-  ReserveRenderProcessToCreateWorker(pending_instance.Pass(), creation_error);
+      new SharedWorkerPendingInstance(std::move(instance)));
+  pending_instance->AddRequest(std::move(request));
+  ReserveRenderProcessToCreateWorker(std::move(pending_instance),
+                                     creation_error);
 }
 
 void SharedWorkerServiceImpl::ForwardToWorker(
     const IPC::Message& message,
     SharedWorkerMessageFilter* filter) {
   for (WorkerHostMap::const_iterator iter = worker_hosts_.begin();
        iter != worker_hosts_.end();
        ++iter) {
     if (iter->second->FilterMessage(message, filter))
       return;
@@ skipping 192 matching lines @@
                      worker_route_id,
                      is_new_worker),
           base::Bind(
               &SharedWorkerServiceImpl::RenderProcessReserveFailedCallback,
               base::Unretained(this),
               pending_instance_id,
               worker_process_id,
               worker_route_id,
               is_new_worker),
           s_try_increment_worker_ref_count_));
-  pending_instances_.set(pending_instance_id, pending_instance.Pass());
+  pending_instances_.set(pending_instance_id, std::move(pending_instance));
 }
 
 void SharedWorkerServiceImpl::RenderProcessReservedCallback(
     int pending_instance_id,
     int worker_process_id,
     int worker_route_id,
     bool is_new_worker,
     bool pause_on_start) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // To offset the TryIncrementWorkerRefCount called for the reservation,
   // calls DecrementWorkerRefCount after CheckWorkerDependency in
   // ScopeWorkerDependencyChecker's destructor.
   ScopedWorkerDependencyChecker checker(
       this, base::Bind(&DecrementWorkerRefCount, worker_process_id));
   scoped_ptr<SharedWorkerPendingInstance> pending_instance =
       pending_instances_.take_and_erase(pending_instance_id);
   if (!pending_instance)
     return;
   if (!is_new_worker) {
     SharedWorkerHost* existing_host =
         worker_hosts_.get(std::make_pair(worker_process_id, worker_route_id));
     if (!existing_host) {
       // Retry reserving a renderer process if the existed Shared Worker was
       // destroyed on IO thread while reserving the renderer process on UI
       // thread.
-      ReserveRenderProcessToCreateWorker(pending_instance.Pass(), NULL);
+      ReserveRenderProcessToCreateWorker(std::move(pending_instance), NULL);
       return;
     }
     pending_instance->RegisterToSharedWorkerHost(existing_host);
     pending_instance->SendWorkerCreatedMessages();
     return;
   }
   SharedWorkerMessageFilter* filter =
       pending_instance->FindFilter(worker_process_id);
   if (!filter) {
     pending_instance->RemoveRequest(worker_process_id);
     // Retry reserving a renderer process if the requested renderer process was
     // destroyed on IO thread while reserving the renderer process on UI thread.
-    ReserveRenderProcessToCreateWorker(pending_instance.Pass(), NULL);
+    ReserveRenderProcessToCreateWorker(std::move(pending_instance), NULL);
     return;
   }
   scoped_ptr<SharedWorkerHost> host(new SharedWorkerHost(
       pending_instance->release_instance(), filter, worker_route_id));
   pending_instance->RegisterToSharedWorkerHost(host.get());
   const GURL url = host->instance()->url();
   const base::string16 name = host->instance()->name();
   host->Start(pause_on_start);
   worker_hosts_.set(std::make_pair(worker_process_id, worker_route_id),
-                    host.Pass());
+                    std::move(host));
   FOR_EACH_OBSERVER(
       WorkerServiceObserver,
       observers_,
       WorkerCreated(url, name, worker_process_id, worker_route_id));
 }
 
 void SharedWorkerServiceImpl::RenderProcessReserveFailedCallback(
     int pending_instance_id,
     int worker_process_id,
     int worker_route_id,
     bool is_new_worker) {
   worker_hosts_.take_and_erase(
       std::make_pair(worker_process_id, worker_route_id));
   scoped_ptr<SharedWorkerPendingInstance> pending_instance =
       pending_instances_.take_and_erase(pending_instance_id);
   if (!pending_instance)
     return;
   pending_instance->RemoveRequest(worker_process_id);
   // Retry reserving a renderer process.
-  ReserveRenderProcessToCreateWorker(pending_instance.Pass(), NULL);
+  ReserveRenderProcessToCreateWorker(std::move(pending_instance), NULL);
 }
 
 SharedWorkerHost* SharedWorkerServiceImpl::FindSharedWorkerHost(
     SharedWorkerMessageFilter* filter,
     int worker_route_id) {
   return worker_hosts_.get(std::make_pair(filter->render_process_id(),
                                           worker_route_id));
 }
 
 SharedWorkerHost* SharedWorkerServiceImpl::FindSharedWorkerHost(
@@ skipping 54 matching lines @@
     UpdateWorkerDependencyFunc new_func) {
   update_worker_dependency_ = new_func;
 }
 
 void SharedWorkerServiceImpl::ChangeTryIncrementWorkerRefCountFuncForTesting(
     bool (*new_func)(int)) {
   s_try_increment_worker_ref_count_ = new_func;
 }
 
 }  // namespace content