Convert Pass()→std::move() on Windows

device/bluetooth/bluetooth_low_energy_win.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 "device/bluetooth/bluetooth_low_energy_win.h"
 
+#include <utility>
+
 #include "base/files/file.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/windows_version.h"
 
 namespace {
 
 static device::win::BluetoothLowEnergyWrapper* g_instance_ = nullptr;
@@ skipping 179 matching lines @@
                                      &required_length,
                                      0);
   if (!CheckSuccess(!!success, kDeviceInfoError, error))
     return false;
   if (!CheckExpectedLength(
           actual_length, required_length, kDeviceInfoError, error)) {
     return false;
   }
 
   (*value) = scoped_ptr<DevicePropertyValue>(
-      new DevicePropertyValue(prop_type, prop_value.Pass(), actual_length));
+      new DevicePropertyValue(prop_type, std::move(prop_value), actual_length));
   return true;
 }
 
 bool CollectBluetoothLowEnergyDeviceRegistryProperty(
     const ScopedDeviceInfoSetHandle& device_info_handle,
     PSP_DEVINFO_DATA device_info_data,
     DWORD property_id,
     scoped_ptr<DeviceRegistryPropertyValue>* value,
     std::string* error) {
   ULONG required_length = 0;
@@ skipping 18 matching lines @@
                                              actual_length,
                                              &required_length);
   if (!CheckSuccess(!!success, kDeviceInfoError, error))
     return false;
   if (!CheckExpectedLength(
           actual_length, required_length, kDeviceInfoError, error)) {
     return false;
   }
 
   (*value) = DeviceRegistryPropertyValue::Create(
-                 property_type, property_value.Pass(), actual_length).Pass();
+      property_type, std::move(property_value), actual_length);
   return true;
 }
 
 bool CollectBluetoothLowEnergyDeviceInstanceId(
     const ScopedDeviceInfoSetHandle& device_info_handle,
     PSP_DEVINFO_DATA device_info_data,
     scoped_ptr<device::win::BluetoothLowEnergyDeviceInfo>& device_info,
     std::string* error) {
   ULONG required_length = 0;
   BOOL success = SetupDiGetDeviceInstanceId(
@@ skipping 216 matching lines @@
       return false;
   }
   if (!CollectBluetoothLowEnergyDeviceAddress(
           device_info_handle, &device_info_data, result, error)) {
     return false;
   }
   if (!CollectBluetoothLowEnergyDeviceStatus(
           device_info_handle, &device_info_data, result, error)) {
     return false;
   }
-  (*device_info) = result.Pass();
+  (*device_info) = std::move(result);
   return true;
 }
 
 enum DeviceInfoResult { kOk, kError, kNoMoreDevices };
 
 // For |device_interface_guid| see the Note of below
 // EnumerateKnownBLEOrBLEGattServiceDevices interface.
 DeviceInfoResult EnumerateSingleBluetoothLowEnergyDevice(
     GUID device_interface_guid,
     const ScopedDeviceInfoSetHandle& device_info_handle,
@@ skipping 30 matching lines @@
 // EnumerateKnownBLEOrBLEGattServiceDevices interface.
 HRESULT OpenBluetoothLowEnergyDevices(GUID device_interface_guid,
                                       ScopedDeviceInfoSetHandle* handle) {
   GUID BluetoothClassGUID = device_interface_guid;
   ScopedDeviceInfoSetHandle result(SetupDiGetClassDevs(
       &BluetoothClassGUID, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE));
   if (!result.IsValid()) {
     return HRESULT_FROM_WIN32(::GetLastError());
   }
 
-  (*handle) = result.Pass();
+  (*handle) = std::move(result);
   return S_OK;
 }
 
 // Enumerate known Bluetooth low energy devices or Bluetooth low energy GATT
 // service devices according to |device_interface_guid|.
 // Note: |device_interface_guid| = GUID_BLUETOOTHLE_DEVICE_INTERFACE corresponds
 // Bluetooth low energy devices. |device_interface_guid| =
 // GUID_BLUETOOTH_GATT_SERVICE_DEVICE_INTERFACE corresponds Bluetooth low energy
 // Gatt service devices.
 bool EnumerateKnownBLEOrBLEGattServiceDevices(
@@ skipping 40 matching lines @@
       CHECK_GE(character_size, 1u);
       WCHAR* value_string = reinterpret_cast<WCHAR*>(value.get());
       value_string[character_size - 1] = 0;
       break;
     }
     case REG_DWORD: {
       CHECK_EQ(value_size, sizeof(DWORD));
       break;
     }
   }
-  return scoped_ptr<DeviceRegistryPropertyValue>(
-      new DeviceRegistryPropertyValue(property_type, value.Pass(), value_size));
+  return make_scoped_ptr(new DeviceRegistryPropertyValue(
+      property_type, std::move(value), value_size));
 }
 
 DeviceRegistryPropertyValue::DeviceRegistryPropertyValue(
     DWORD property_type,
     scoped_ptr<uint8_t[]> value,
     size_t value_size)
     : property_type_(property_type),
-      value_(value.Pass()),
-      value_size_(value_size) {
-}
+      value_(std::move(value)),
+      value_size_(value_size) {}
 
 DeviceRegistryPropertyValue::~DeviceRegistryPropertyValue() {
 }
 
 std::string DeviceRegistryPropertyValue::AsString() const {
   CHECK_EQ(property_type_, static_cast<DWORD>(REG_SZ));
   WCHAR* value_string = reinterpret_cast<WCHAR*>(value_.get());
   return base::SysWideToUTF8(value_string);
 }
 
 DWORD DeviceRegistryPropertyValue::AsDWORD() const {
   CHECK_EQ(property_type_, static_cast<DWORD>(REG_DWORD));
   DWORD* value = reinterpret_cast<DWORD*>(value_.get());
   return *value;
 }
 
 DevicePropertyValue::DevicePropertyValue(DEVPROPTYPE property_type,
                                          scoped_ptr<uint8_t[]> value,
                                          size_t value_size)
     : property_type_(property_type),
-      value_(value.Pass()),
-      value_size_(value_size) {
-}
+      value_(std::move(value)),
+      value_size_(value_size) {}
 
 DevicePropertyValue::~DevicePropertyValue() {
 }
 
 uint32_t DevicePropertyValue::AsUint32() const {
   CHECK_EQ(property_type_, static_cast<DEVPROPTYPE>(DEVPROP_TYPE_UINT32));
   CHECK_EQ(value_size_, sizeof(uint32_t));
   return *reinterpret_cast<uint32_t*>(value_.get());
 }
 
@@ skipping 145 matching lines @@
 
   if (FAILED(hr)) {
     out_included_descriptors->reset(nullptr);
     *out_counts = 0;
   }
   return hr;
 }
 
 }  // namespace win
 }  // namespace device