Convert Pass()→std::move() for Mac build.

device/bluetooth/bluetooth_socket_mac.mm

 // 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 "device/bluetooth/bluetooth_socket_mac.h"
 
 #import <IOBluetooth/IOBluetooth.h>
 #include <stdint.h>
 
 #include <limits>
 #include <sstream>
 #include <string>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/memory/ref_counted.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
@@ skipping 618 matching lines @@
 
 void BluetoothSocketMac::OnChannelOpenComplete(
     const std::string& device_address,
     IOReturn status) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(is_connecting());
 
   DVLOG(1) << device_address << " " << uuid_.canonical_value()
            << ": channel open complete.";
 
-  scoped_ptr<ConnectCallbacks> temp = connect_callbacks_.Pass();
+  scoped_ptr<ConnectCallbacks> temp = std::move(connect_callbacks_);
   if (status != kIOReturnSuccess) {
     ReleaseChannel();
     std::stringstream error;
     error << "Failed to connect bluetooth socket (" << device_address << "): ("
           << status << ")";
     temp->error_callback.Run(error.str());
     return;
   }
 
   temp->success_callback.Run();
@@ skipping 55 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!is_connecting());
 
   int data_size = base::checked_cast<int>(length);
   scoped_refptr<net::IOBufferWithSize> buffer(
       new net::IOBufferWithSize(data_size));
   memcpy(buffer->data(), data, buffer->size());
 
   // If there is a pending read callback, call it now.
   if (receive_callbacks_) {
-    scoped_ptr<ReceiveCallbacks> temp = receive_callbacks_.Pass();
+    scoped_ptr<ReceiveCallbacks> temp = std::move(receive_callbacks_);
     temp->success_callback.Run(buffer->size(), buffer);
     return;
   }
 
   // Otherwise, enqueue the buffer for later use
   receive_queue_.push(buffer);
 }
 
 void BluetoothSocketMac::Send(scoped_refptr<net::IOBuffer> buffer,
                               int buffer_size,
@@ skipping 89 matching lines @@
     }
   } else {
     request->success_callback.Run(request->buffer_size);
   }
 }
 
 void BluetoothSocketMac::OnChannelClosed() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (receive_callbacks_) {
-    scoped_ptr<ReceiveCallbacks> temp = receive_callbacks_.Pass();
+    scoped_ptr<ReceiveCallbacks> temp = std::move(receive_callbacks_);
     temp->error_callback.Run(BluetoothSocket::kDisconnected,
                              kSocketNotConnected);
   }
 
   ReleaseChannel();
 }
 
 void BluetoothSocketMac::Accept(
     const AcceptCompletionCallback& success_callback,
     const ErrorCompletionCallback& error_callback) {
@@ skipping 93 matching lines @@
   rfcomm_connection_listener_.reset();
   l2cap_connection_listener_.reset();
 
   // Destroying the listener above prevents the callback delegate from being
   // called so it is now safe to release all callback state.
   accept_request_.reset();
   empty_queue(accept_queue_);
 }
 
 }  // namespace device