Convert Pass()→std::move() in //mojo/public/

mojo/public/cpp/bindings/lib/multiplex_router.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 "mojo/public/cpp/bindings/lib/multiplex_router.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 103 matching lines @@
   Task() {}
 };
 
 MultiplexRouter::MultiplexRouter(bool set_interface_id_namesapce_bit,
                                  ScopedMessagePipeHandle message_pipe,
                                  const MojoAsyncWaiter* waiter)
     : RefCountedDeleteOnMessageLoop(base::MessageLoop::current()
                                         ->task_runner()),
       set_interface_id_namespace_bit_(set_interface_id_namesapce_bit),
       header_validator_(this),
-      connector_(message_pipe.Pass(), Connector::MULTI_THREADED_SEND, waiter),
+      connector_(std::move(message_pipe),
+                 Connector::MULTI_THREADED_SEND,
+                 waiter),
       encountered_error_(false),
       control_message_handler_(this),
       control_message_proxy_(&connector_),
       next_interface_id_value_(1),
       testing_mode_(false) {
   connector_.set_incoming_receiver(&header_validator_);
   connector_.set_connection_error_handler(
       [this]() { OnPipeConnectionError(); });
 }
 
@@ skipping 148 matching lines @@
     connector_.RaiseError();
   } else {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&MultiplexRouter::RaiseError, this));
   }
 }
 
 scoped_ptr<AssociatedGroup> MultiplexRouter::CreateAssociatedGroup() {
   scoped_ptr<AssociatedGroup> group(new AssociatedGroup);
   group->router_ = this;
-  return group.Pass();
+  return group;
 }
 
 // static
 MultiplexRouter* MultiplexRouter::GetRouter(AssociatedGroup* associated_group) {
   return associated_group->router_.get();
 }
 
 bool MultiplexRouter::HasAssociatedEndpoints() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   base::AutoLock locker(lock_);
@@ skipping 86 matching lines @@
     UpdateEndpointStateMayRemove(endpoint, PEER_ENDPOINT_CLOSED);
   }
 
   ProcessTasks(false);
 }
 
 void MultiplexRouter::ProcessTasks(bool force_async) {
   lock_.AssertAcquired();
 
   while (!tasks_.empty()) {
-    scoped_ptr<Task> task(tasks_.front().Pass());
+    scoped_ptr<Task> task(std::move(tasks_.front()));
     tasks_.pop_front();
 
     bool processed = task->IsNotifyErrorTask()
                          ? ProcessNotifyErrorTask(task.get(), &force_async)
                          : ProcessIncomingMessageTask(task.get(), &force_async);
 
     if (!processed) {
-      tasks_.push_front(task.Pass());
+      tasks_.push_front(std::move(task));
       break;
     }
   }
 }
 
 bool MultiplexRouter::ProcessNotifyErrorTask(Task* task, bool* force_async) {
   lock_.AssertAcquired();
   InterfaceEndpoint* endpoint = task->endpoint_to_notify.get();
   if (!endpoint->client())
     return true;
@@ skipping 59 matching lines @@
   }
 
   if (!endpoint->task_runner()->BelongsToCurrentThread() || *force_async) {
     endpoint->task_runner()->PostTask(
         FROM_HERE, base::Bind(&MultiplexRouter::LockAndCallProcessTasks, this));
     return false;
   }
 
   *force_async = true;
   InterfaceEndpointClient* client = endpoint->client();
-  scoped_ptr<Message> owned_message = task->message.Pass();
+  scoped_ptr<Message> owned_message = std::move(task->message);
   bool result = false;
   {
     // We must unlock before calling into |client| because it may call this
     // object within HandleIncomingMessage(). Holding the lock will lead to
     // deadlock.
     //
     // It is safe to call into |client| without the lock. Because |client| is
     // always accessed on the same thread, including DetachEndpointClient().
     base::AutoUnlock unlocker(lock_);
     result = client->HandleIncomingMessage(owned_message.get());
@@ skipping 27 matching lines @@
 }
 
 void MultiplexRouter::RaiseErrorInNonTestingMode() {
   lock_.AssertAcquired();
   if (!testing_mode_)
     RaiseError();
 }
 
 }  // namespace internal
 }  // namespace mojo