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

content/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.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 "content/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "device/bluetooth/bluetooth_adapter.h"
@@ skipping 291 matching lines @@
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetPowerValueAdapter(int8_t tx_power,
                                                          int8_t rssi) {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
   scoped_ptr<NiceMockBluetoothDevice> device(GetHeartRateDevice(adapter.get()));
 
   ON_CALL(*device, GetInquiryTxPower()).WillByDefault(Return(tx_power));
   ON_CALL(*device, GetInquiryRSSI()).WillByDefault(Return(rssi));
 
-  adapter->AddMockDevice(device.Pass());
+  adapter->AddMockDevice(std::move(device));
 
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetPowerPresenceAdapter(
     bool tx_power_present,
     bool rssi_present) {
   // TODO(ortuno): RSSI Unknown and Tx Power Unknown should have different
@@ skipping 24 matching lines @@
   adapter->AddMockDevice(GetBaseDevice(adapter.get(), "❤❤❤❤❤❤❤❤❤"));
 
   return adapter;
 }
 
 // Adds a device to |adapter| and notifies all observers about that new device.
 // Mocks can call this asynchronously to cause changes in the middle of a test.
 static void AddDevice(scoped_refptr<NiceMockBluetoothAdapter> adapter,
                       scoped_ptr<NiceMockBluetoothDevice> new_device) {
   NiceMockBluetoothDevice* new_device_ptr = new_device.get();
-  adapter->AddMockDevice(new_device.Pass());
+  adapter->AddMockDevice(std::move(new_device));
   FOR_EACH_OBSERVER(BluetoothAdapter::Observer, adapter->GetObservers(),
                     DeviceAdded(adapter.get(), new_device_ptr));
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetSecondDiscoveryFindsHeartRateAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetPoweredAdapter());
   NiceMockBluetoothAdapter* adapter_ptr = adapter.get();
 
@@ skipping 32 matching lines @@
 
   scoped_ptr<NiceMockBluetoothDevice> device(GetHeartRateDevice(adapter.get()));
 
   scoped_ptr<NiceMockBluetoothGattService> generic_access(
       GetBaseGATTService(device.get(), kGenericAccessServiceUUID));
   scoped_ptr<NiceMockBluetoothGattService> heart_rate(
       GetBaseGATTService(device.get(), kHeartRateServiceUUID));
 
   // Intentionally NOT adding a characteristic to heart_rate service.
 
-  device->AddMockService(generic_access.Pass());
-  device->AddMockService(heart_rate.Pass());
-  adapter->AddMockDevice(device.Pass());
+  device->AddMockService(std::move(generic_access));
+  device->AddMockService(std::move(heart_rate));
+  adapter->AddMockDevice(std::move(device));
 
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetDelayedServicesDiscoveryAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
   scoped_ptr<NiceMockBluetoothDevice> device(GetHeartRateDevice(adapter.get()));
 
@@ skipping 15 matching lines @@
         std::vector<BluetoothGattService*> services =
             device_ptr->GetMockServices();
 
         if (services.size() > 0) {
           return services;
         }
 
         scoped_ptr<NiceMockBluetoothGattService> heart_rate(
             GetBaseGATTService(device_ptr, kHeartRateServiceUUID));
 
-        device_ptr->AddMockService(heart_rate.Pass());
+        device_ptr->AddMockService(std::move(heart_rate));
         base::ThreadTaskRunnerHandle::Get()->PostTask(
             FROM_HERE, base::Bind(&NotifyServicesDiscovered,
                                   make_scoped_refptr(adapter_ptr), device_ptr));
 
         DCHECK(services.size() == 0);
         return services;
       }));
 
-  adapter->AddMockDevice(device.Pass());
+  adapter->AddMockDevice(std::move(device));
 
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetHeartRateAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
   scoped_ptr<NiceMockBluetoothDevice> device(GetHeartRateDevice(adapter.get()));
 
   // TODO(ortuno): Implement the rest of the service's characteristics
   // See: http://crbug.com/529975
 
   device->AddMockService(GetGenericAccessService(adapter.get(), device.get()));
   device->AddMockService(GetHeartRateService(adapter.get(), device.get()));
-  adapter->AddMockDevice(device.Pass());
+  adapter->AddMockDevice(std::move(device));
 
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetFailingConnectionsAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
 
   for (int error = BluetoothDevice::ERROR_UNKNOWN;
@@ skipping 21 matching lines @@
   scoped_ptr<NiceMockBluetoothGattService> service(
       GetBaseGATTService(device.get(), errorsServiceUUID));
 
   for (int error = BluetoothGattService::GATT_ERROR_UNKNOWN;
        error <= BluetoothGattService::GATT_ERROR_NOT_SUPPORTED; error++) {
     service->AddMockCharacteristic(GetErrorCharacteristic(
         service.get(),
         static_cast<BluetoothGattService::GattErrorCode>(error)));
   }
 
-  device->AddMockService(service.Pass());
-  adapter->AddMockDevice(device.Pass());
+  device->AddMockService(std::move(service));
+  adapter->AddMockDevice(std::move(device));
 
   return adapter;
 }
 
 // Discovery Sessions
 
 // static
 scoped_ptr<NiceMockBluetoothDiscoverySession>
 LayoutTestBluetoothAdapterProvider::GetDiscoverySession() {
   scoped_ptr<NiceMockBluetoothDiscoverySession> discovery_session(
@@ skipping 159 matching lines @@
   std::vector<uint8_t> device_name_value(device_name_str.begin(),
                                          device_name_str.end());
 
   ON_CALL(*device_name, ReadRemoteCharacteristic(_, _))
       .WillByDefault(RunCallback<0>(device_name_value));
 
   // Write response.
   ON_CALL(*device_name, WriteRemoteCharacteristic(_, _, _))
       .WillByDefault(RunCallback<1 /* success callback */>());
 
-  generic_access->AddMockCharacteristic(device_name.Pass());
+  generic_access->AddMockCharacteristic(std::move(device_name));
 
   return generic_access;
 }
 
 // static
 scoped_ptr<NiceMockBluetoothGattService>
 LayoutTestBluetoothAdapterProvider::GetHeartRateService(
     MockBluetoothAdapter* adapter,
     MockBluetoothDevice* device) {
   scoped_ptr<NiceMockBluetoothGattService> heart_rate(
@@ skipping 34 matching lines @@
             location[0] = 1;  // Chest
             // Read a characteristic has a side effect of
             // GattCharacteristicValueChanged being called.
             FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
                               adapter->GetObservers(),
                               GattCharacteristicValueChanged(
                                   adapter, location_ptr, location));
             return location;
           }));
 
-  heart_rate->AddMockCharacteristic(heart_rate_measurement.Pass());
-  heart_rate->AddMockCharacteristic(body_sensor_location.Pass());
+  heart_rate->AddMockCharacteristic(std::move(heart_rate_measurement));
+  heart_rate->AddMockCharacteristic(std::move(body_sensor_location));
 
   return heart_rate;
 }
 
 // Characteristics
 
 // static
 scoped_ptr<NiceMockBluetoothGattCharacteristic>
 LayoutTestBluetoothAdapterProvider::GetBaseGATTCharacteristic(
     MockBluetoothGattService* service,
@@ skipping 60 matching lines @@
   return base::StringPrintf("%08x-97e5-4cd7-b9f1-f5a427670c59", alias);
 }
 
 // static
 std::string LayoutTestBluetoothAdapterProvider::makeMACAddress(uint64_t addr) {
   return BluetoothDevice::CanonicalizeAddress(
       base::StringPrintf("%012" PRIx64, addr));
 }
 
 }  // namespace content