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

mojo/public/cpp/bindings/lib/connector.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 "mojo/public/cpp/bindings/lib/connector.h"
 
 #include <stdint.h>
+#include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/synchronization/lock.h"
 
 namespace mojo {
 namespace internal {
 
 namespace {
 
@@ skipping 19 matching lines @@
 };
 
 }  // namespace
 
 // ----------------------------------------------------------------------------
 
 Connector::Connector(ScopedMessagePipeHandle message_pipe,
                      ConnectorConfig config,
                      const MojoAsyncWaiter* waiter)
     : waiter_(waiter),
-      message_pipe_(message_pipe.Pass()),
+      message_pipe_(std::move(message_pipe)),
       incoming_receiver_(nullptr),
       async_wait_id_(0),
       error_(false),
       drop_writes_(false),
       enforce_errors_from_incoming_receiver_(true),
       paused_(false),
       destroyed_flag_(nullptr),
       lock_(config == MULTI_THREADED_SEND ? new base::Lock : nullptr) {
   // Even though we don't have an incoming receiver, we still want to monitor
   // the message pipe to know if is closed or encounters an error.
   WaitToReadMore();
 }
 
 Connector::~Connector() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (destroyed_flag_)
     *destroyed_flag_ = true;
 
   CancelWait();
 }
 
 void Connector::CloseMessagePipe() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   CancelWait();
   MayAutoLock locker(lock_.get());
-  Close(message_pipe_.Pass());
+  Close(std::move(message_pipe_));
 }
 
 ScopedMessagePipeHandle Connector::PassMessagePipe() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   CancelWait();
   MayAutoLock locker(lock_.get());
-  return message_pipe_.Pass();
+  return std::move(message_pipe_);
 }
 
 void Connector::RaiseError() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   HandleError(true, true);
 }
 
 bool Connector::WaitForIncomingMessage(MojoDeadline deadline) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 193 matching lines @@
   if (paused_) {
     // If the user has paused receiving messages, we shouldn't call the error
     // handler right away. We need to wait until the user starts receiving
     // messages again.
     force_async_handler = true;
   }
 
   if (force_pipe_reset) {
     CancelWait();
     MayAutoLock locker(lock_.get());
-    Close(message_pipe_.Pass());
+    Close(std::move(message_pipe_));
     MessagePipe dummy_pipe;
-    message_pipe_ = dummy_pipe.handle0.Pass();
+    message_pipe_ = std::move(dummy_pipe.handle0);
   } else {
     CancelWait();
   }
 
   if (force_async_handler) {
     // |dummy_pipe.handle1| has been destructed. Reading the pipe will
     // eventually cause a read error on |message_pipe_| and set error state.
     if (!paused_)
       WaitToReadMore();
   } else {
     error_ = true;
     connection_error_handler_.Run();
   }
 }
 
 }  // namespace internal
 }  // namespace mojo