Convert Pass()→std::move() in //device

device/bluetooth/dbus/fake_bluetooth_device_client.cc

 // Copyright (c) 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/dbus/fake_bluetooth_device_client.h"
 
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/socket.h>
 #include <sys/types.h>
@@ skipping 461 matching lines @@
 
   base::WorkerPool::GetTaskRunner(false)
       ->PostTask(FROM_HERE, base::Bind(&SimulatedProfileSocket, fds[0]));
 
   scoped_ptr<dbus::FileDescriptor> fd(new dbus::FileDescriptor(fds[1]));
 
   // Post the new connection to the service provider.
   BluetoothProfileServiceProvider::Delegate::Options options;
 
   profile_service_provider->NewConnection(
-      object_path, fd.Pass(), options,
+      object_path, std::move(fd), options,
       base::Bind(&FakeBluetoothDeviceClient::ConnectionCallback,
                  base::Unretained(this), object_path, callback,
                  error_callback));
 }
 
 void FakeBluetoothDeviceClient::DisconnectProfile(
     const dbus::ObjectPath& object_path,
     const std::string& uuid,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
@@ skipping 263 matching lines @@
   pairedDevice->SetString("name", kPairedDeviceName);
   pairedDevice->SetString("alias", kPairedDeviceName);
   pairedDevice->SetString("pairingMethod", "");
   pairedDevice->SetString("pairingAuthToken", "");
   pairedDevice->SetString("pairingAction", "");
   pairedDevice->SetInteger("classValue", kPairedDeviceClass);
   pairedDevice->SetBoolean("discoverable", true);
   pairedDevice->SetBoolean("isTrusted", true);
   pairedDevice->SetBoolean("paired", true);
   pairedDevice->SetBoolean("incoming", false);
-  predefined_devices->Append(pairedDevice.Pass());
+  predefined_devices->Append(std::move(pairedDevice));
 
   scoped_ptr<base::DictionaryValue> legacyDevice(new base::DictionaryValue);
   legacyDevice->SetString("path", kLegacyAutopairPath);
   legacyDevice->SetString("address", kLegacyAutopairAddress);
   legacyDevice->SetString("name", kLegacyAutopairName);
   legacyDevice->SetString("alias", kLegacyAutopairName);
   legacyDevice->SetString("pairingMethod", "");
   legacyDevice->SetString("pairingAuthToken", "");
   legacyDevice->SetString("pairingAction", "");
   legacyDevice->SetInteger("classValue", kLegacyAutopairClass);
   legacyDevice->SetBoolean("isTrusted", true);
   legacyDevice->SetBoolean("discoverable", false);
   legacyDevice->SetBoolean("paired", false);
   legacyDevice->SetBoolean("incoming", false);
-  predefined_devices->Append(legacyDevice.Pass());
+  predefined_devices->Append(std::move(legacyDevice));
 
   scoped_ptr<base::DictionaryValue> pin(new base::DictionaryValue);
   pin->SetString("path", kDisplayPinCodePath);
   pin->SetString("address", kDisplayPinCodeAddress);
   pin->SetString("name", kDisplayPinCodeName);
   pin->SetString("alias", kDisplayPinCodeName);
   pin->SetString("pairingMethod", kPairingMethodPinCode);
   pin->SetString("pairingAuthToken", kTestPinCode);
   pin->SetString("pairingAction", kPairingActionDisplay);
   pin->SetInteger("classValue", kDisplayPinCodeClass);
   pin->SetBoolean("isTrusted", false);
   pin->SetBoolean("discoverable", false);
   pin->SetBoolean("paired", false);
   pin->SetBoolean("incoming", false);
-  predefined_devices->Append(pin.Pass());
+  predefined_devices->Append(std::move(pin));
 
   scoped_ptr<base::DictionaryValue> vanishing(new base::DictionaryValue);
   vanishing->SetString("path", kVanishingDevicePath);
   vanishing->SetString("address", kVanishingDeviceAddress);
   vanishing->SetString("name", kVanishingDeviceName);
   vanishing->SetString("alias", kVanishingDeviceName);
   vanishing->SetString("pairingMethod", "");
   vanishing->SetString("pairingAuthToken", "");
   vanishing->SetString("pairingAction", "");
   vanishing->SetInteger("classValue", kVanishingDeviceClass);
   vanishing->SetBoolean("isTrusted", false);
   vanishing->SetBoolean("discoverable", false);
   vanishing->SetBoolean("paired", false);
   vanishing->SetBoolean("incoming", false);
-  predefined_devices->Append(vanishing.Pass());
+  predefined_devices->Append(std::move(vanishing));
 
   scoped_ptr<base::DictionaryValue> connect_unpairable(
       new base::DictionaryValue);
   connect_unpairable->SetString("path", kConnectUnpairablePath);
   connect_unpairable->SetString("address", kConnectUnpairableAddress);
   connect_unpairable->SetString("name", kConnectUnpairableName);
   connect_unpairable->SetString("pairingMethod", "");
   connect_unpairable->SetString("pairingAuthToken", "");
   connect_unpairable->SetString("pairingAction", "");
   connect_unpairable->SetString("alias", kConnectUnpairableName);
   connect_unpairable->SetInteger("classValue", kConnectUnpairableClass);
   connect_unpairable->SetBoolean("isTrusted", false);
   connect_unpairable->SetBoolean("discoverable", false);
   connect_unpairable->SetBoolean("paired", false);
   connect_unpairable->SetBoolean("incoming", false);
-  predefined_devices->Append(connect_unpairable.Pass());
+  predefined_devices->Append(std::move(connect_unpairable));
 
   scoped_ptr<base::DictionaryValue> passkey(new base::DictionaryValue);
   passkey->SetString("path", kDisplayPasskeyPath);
   passkey->SetString("address", kDisplayPasskeyAddress);
   passkey->SetString("name", kDisplayPasskeyName);
   passkey->SetString("alias", kDisplayPasskeyName);
   passkey->SetString("pairingMethod", kPairingMethodPassKey);
   passkey->SetInteger("pairingAuthToken", kTestPassKey);
   passkey->SetString("pairingAction", kPairingActionDisplay);
   passkey->SetInteger("classValue", kDisplayPasskeyClass);
   passkey->SetBoolean("isTrusted", false);
   passkey->SetBoolean("discoverable", false);
   passkey->SetBoolean("paired", false);
   passkey->SetBoolean("incoming", false);
-  predefined_devices->Append(passkey.Pass());
+  predefined_devices->Append(std::move(passkey));
 
   scoped_ptr<base::DictionaryValue> request_pin(new base::DictionaryValue);
   request_pin->SetString("path", kRequestPinCodePath);
   request_pin->SetString("address", kRequestPinCodeAddress);
   request_pin->SetString("name", kRequestPinCodeName);
   request_pin->SetString("alias", kRequestPinCodeName);
   request_pin->SetString("pairingMethod", "");
   request_pin->SetString("pairingAuthToken", "");
   request_pin->SetString("pairingAction", kPairingActionRequest);
   request_pin->SetInteger("classValue", kRequestPinCodeClass);
   request_pin->SetBoolean("isTrusted", false);
   request_pin->SetBoolean("discoverable", false);
   request_pin->SetBoolean("paired", false);
   request_pin->SetBoolean("incoming", false);
-  predefined_devices->Append(request_pin.Pass());
+  predefined_devices->Append(std::move(request_pin));
 
   scoped_ptr<base::DictionaryValue> confirm(new base::DictionaryValue);
   confirm->SetString("path", kConfirmPasskeyPath);
   confirm->SetString("address", kConfirmPasskeyAddress);
   confirm->SetString("name", kConfirmPasskeyName);
   confirm->SetString("alias", kConfirmPasskeyName);
   confirm->SetString("pairingMethod", "");
   confirm->SetInteger("pairingAuthToken", kTestPassKey);
   confirm->SetString("pairingAction", kPairingActionConfirmation);
   confirm->SetInteger("classValue", kConfirmPasskeyClass);
   confirm->SetBoolean("isTrusted", false);
   confirm->SetBoolean("discoverable", false);
   confirm->SetBoolean("paired", false);
   confirm->SetBoolean("incoming", false);
-  predefined_devices->Append(confirm.Pass());
+  predefined_devices->Append(std::move(confirm));
 
   scoped_ptr<base::DictionaryValue> request_passkey(new base::DictionaryValue);
   request_passkey->SetString("path", kRequestPasskeyPath);
   request_passkey->SetString("address", kRequestPasskeyAddress);
   request_passkey->SetString("name", kRequestPasskeyName);
   request_passkey->SetString("alias", kRequestPasskeyName);
   request_passkey->SetString("pairingMethod", kPairingMethodPassKey);
   request_passkey->SetString("pairingAction", kPairingActionRequest);
   request_passkey->SetInteger("pairingAuthToken", kTestPassKey);
   request_passkey->SetInteger("classValue", kRequestPasskeyClass);
   request_passkey->SetBoolean("isTrusted", false);
   request_passkey->SetBoolean("discoverable", false);
   request_passkey->SetBoolean("paired", false);
   request_passkey->SetBoolean("incoming", false);
-  predefined_devices->Append(request_passkey.Pass());
+  predefined_devices->Append(std::move(request_passkey));
 
   scoped_ptr<base::DictionaryValue> unconnectable(new base::DictionaryValue);
   unconnectable->SetString("path", kUnconnectableDevicePath);
   unconnectable->SetString("address", kUnconnectableDeviceAddress);
   unconnectable->SetString("name", kUnconnectableDeviceName);
   unconnectable->SetString("alias", kUnconnectableDeviceName);
   unconnectable->SetString("pairingMethod", "");
   unconnectable->SetString("pairingAuthToken", "");
   unconnectable->SetString("pairingAction", "");
   unconnectable->SetInteger("classValue", kUnconnectableDeviceClass);
   unconnectable->SetBoolean("isTrusted", true);
   unconnectable->SetBoolean("discoverable", false);
   unconnectable->SetBoolean("paired", false);
   unconnectable->SetBoolean("incoming", false);
-  predefined_devices->Append(unconnectable.Pass());
+  predefined_devices->Append(std::move(unconnectable));
 
   scoped_ptr<base::DictionaryValue> unpairable(new base::DictionaryValue);
   unpairable->SetString("path", kUnpairableDevicePath);
   unpairable->SetString("address", kUnpairableDeviceAddress);
   unpairable->SetString("name", kUnpairableDeviceName);
   unpairable->SetString("alias", kUnpairableDeviceName);
   unpairable->SetString("pairingMethod", "");
   unpairable->SetString("pairingAuthToken", "");
   unpairable->SetString("pairingAction", kPairingActionFail);
   unpairable->SetInteger("classValue", kUnpairableDeviceClass);
   unpairable->SetBoolean("isTrusted", false);
   unpairable->SetBoolean("discoverable", false);
   unpairable->SetBoolean("paired", false);
   unpairable->SetBoolean("incoming", false);
-  predefined_devices->Append(unpairable.Pass());
+  predefined_devices->Append(std::move(unpairable));
 
   scoped_ptr<base::DictionaryValue> just_works(new base::DictionaryValue);
   just_works->SetString("path", kJustWorksPath);
   just_works->SetString("address", kJustWorksAddress);
   just_works->SetString("name", kJustWorksName);
   just_works->SetString("alias", kJustWorksName);
   just_works->SetString("pairingMethod", "");
   just_works->SetString("pairingAuthToken", "");
   just_works->SetString("pairingAction", "");
   just_works->SetInteger("classValue", kJustWorksClass);
   just_works->SetBoolean("isTrusted", false);
   just_works->SetBoolean("discoverable", false);
   just_works->SetBoolean("paired", false);
   just_works->SetBoolean("incoming", false);
-  predefined_devices->Append(just_works.Pass());
+  predefined_devices->Append(std::move(just_works));
 
   scoped_ptr<base::DictionaryValue> low_energy(new base::DictionaryValue);
   low_energy->SetString("path", kLowEnergyPath);
   low_energy->SetString("address", kLowEnergyAddress);
   low_energy->SetString("name", kLowEnergyName);
   low_energy->SetString("alias", kLowEnergyName);
   low_energy->SetString("pairingMethod", "");
   low_energy->SetString("pairingAuthToken", "");
   low_energy->SetString("pairingAction", "");
   low_energy->SetInteger("classValue", kLowEnergyClass);
   low_energy->SetBoolean("isTrusted", false);
   low_energy->SetBoolean("discoverable", false);
   low_energy->SetBoolean("paireed", false);
   low_energy->SetBoolean("incoming", false);
-  predefined_devices->Append(low_energy.Pass());
+  predefined_devices->Append(std::move(low_energy));
 
   scoped_ptr<base::DictionaryValue> paired_unconnectable(
       new base::DictionaryValue);
   paired_unconnectable->SetString("path", kPairedUnconnectableDevicePath);
   paired_unconnectable->SetString("address", kPairedUnconnectableDeviceAddress);
   paired_unconnectable->SetString("name", kPairedUnconnectableDeviceName);
   paired_unconnectable->SetString("pairingMethod", "");
   paired_unconnectable->SetString("pairingAuthToken", "");
   paired_unconnectable->SetString("pairingAction", "");
   paired_unconnectable->SetString("alias", kPairedUnconnectableDeviceName);
   paired_unconnectable->SetInteger("classValue",
                                    kPairedUnconnectableDeviceClass);
   paired_unconnectable->SetBoolean("isTrusted", false);
   paired_unconnectable->SetBoolean("discoverable", true);
   paired_unconnectable->SetBoolean("paired", true);
   paired_unconnectable->SetBoolean("incoming", false);
-  predefined_devices->Append(paired_unconnectable.Pass());
+  predefined_devices->Append(std::move(paired_unconnectable));
 
   scoped_ptr<base::DictionaryValue> connected_trusted_not_paired(
       new base::DictionaryValue);
   connected_trusted_not_paired->SetString("path",
                                           kConnectedTrustedNotPairedDevicePath);
   connected_trusted_not_paired->SetString(
       "address", kConnectedTrustedNotPairedDeviceAddress);
   connected_trusted_not_paired->SetString("name",
                                           kConnectedTrustedNotPairedDeviceName);
   connected_trusted_not_paired->SetString("pairingMethod", "");
   connected_trusted_not_paired->SetString("pairingAuthToken", "");
   connected_trusted_not_paired->SetString("pairingAction", "");
   connected_trusted_not_paired->SetString("alias",
                                           kConnectedTrustedNotPairedDeviceName);
   connected_trusted_not_paired->SetInteger(
       "classValue", kConnectedTrustedNotPairedDeviceClass);
   connected_trusted_not_paired->SetBoolean("isTrusted", true);
   connected_trusted_not_paired->SetBoolean("discoverable", true);
   connected_trusted_not_paired->SetBoolean("paired", false);
   connected_trusted_not_paired->SetBoolean("incoming", false);
-  predefined_devices->Append(connected_trusted_not_paired.Pass());
+  predefined_devices->Append(std::move(connected_trusted_not_paired));
 
-  return predefined_devices.Pass();
+  return predefined_devices;
 }
 
 void FakeBluetoothDeviceClient::RemoveDevice(
     const dbus::ObjectPath& adapter_path,
     const dbus::ObjectPath& device_path) {
   std::vector<dbus::ObjectPath>::iterator listiter =
       std::find(device_list_.begin(), device_list_.end(), device_path);
   if (listiter == device_list_.end())
     return;
 
@@ skipping 664 matching lines @@
     // TODO(keybuk): tear down this side of the connection
     callback.Run();
   } else if (status == BluetoothProfileServiceProvider::Delegate::CANCELLED) {
     error_callback.Run(bluetooth_device::kErrorFailed, "Canceled");
   } else if (status == BluetoothProfileServiceProvider::Delegate::REJECTED) {
     error_callback.Run(bluetooth_device::kErrorFailed, "Rejected");
   }
 }
 
 }  // namespace bluez