Remove the TYPE_WITH_MOVE_CONSTRUCTOR_FOR_CPP_03 macro.

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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/format_macros.h"
 #include "base/location.h"
@@ skipping 198 matching lines @@
   // modified and have devices added to it. The call to ::GetDevices will
   // invoke ::GetConstMockDevices, returning all devices added up to that time.
   ON_CALL(*adapter, GetDevices())
       .WillByDefault(
           Invoke(adapter.get(), &MockBluetoothAdapter::GetConstMockDevices));
 
   // The call to ::GetDevice will invoke GetMockDevice which returns a device
   // matching the address provided if the device was added to the mock.
   ON_CALL(*adapter, GetDevice(_)).WillByDefault(GetMockDevice(adapter.get()));
 
-  return adapter.Pass();
+  return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetPresentAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetBaseAdapter());
   ON_CALL(*adapter, IsPresent()).WillByDefault(Return(true));
 
-  return adapter.Pass();
+  return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetNotPresentAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetBaseAdapter());
   ON_CALL(*adapter, IsPresent()).WillByDefault(Return(false));
 
-  return adapter.Pass();
+  return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetPoweredAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetPresentAdapter());
   ON_CALL(*adapter, IsPowered()).WillByDefault(Return(true));
 
-  return adapter.Pass();
+  return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetNotPoweredAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetPresentAdapter());
   ON_CALL(*adapter, IsPowered()).WillByDefault(Return(false));
 
-  return adapter.Pass();
+  return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetScanFilterCheckingAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetPoweredAdapter());
 
   // This fails the test with an error message listing actual and expected UUIDs
   // if StartDiscoverySessionWithFilter() is called with the wrong argument.
   EXPECT_CALL(
       *adapter,
       StartDiscoverySessionWithFilterRaw(
           ResultOf(&GetUUIDs, ElementsAre(BluetoothUUID(kGlucoseServiceUUID),
                                           BluetoothUUID(kHeartRateServiceUUID),
                                           BluetoothUUID(kBatteryServiceUUID))),
           _, _))
       .WillRepeatedly(RunCallbackWithResult<1 /* success_callback */>(
           []() { return GetDiscoverySession(); }));
 
   // Any unexpected call results in the failure callback.
   ON_CALL(*adapter, StartDiscoverySessionWithFilterRaw(_, _, _))
       .WillByDefault(RunCallback<2 /* error_callback */>());
 
   // We need to add a device otherwise requestDevice would reject.
   adapter->AddMockDevice(GetBatteryDevice(adapter.get()));
 
-  return adapter.Pass();
+  return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetFailStartDiscoveryAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetPoweredAdapter());
 
   ON_CALL(*adapter, StartDiscoverySessionWithFilterRaw(_, _, _))
       .WillByDefault(RunCallback<2 /* error_callback */>());
 
-  return adapter.Pass();
+  return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetEmptyAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetPoweredAdapter());
 
   ON_CALL(*adapter, StartDiscoverySessionWithFilterRaw(_, _, _))
       .WillByDefault(RunCallbackWithResult<1 /* success_callback */>(
           []() { return GetDiscoverySession(); }));
 
-  return adapter.Pass();
+  return adapter;
 }
 
 // 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));
@@ skipping 19 matching lines @@
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetGlucoseHeartRateAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
 
   adapter->AddMockDevice(GetHeartRateDevice(adapter.get()));
   adapter->AddMockDevice(GetGlucoseDevice(adapter.get()));
 
-  return adapter.Pass();
+  return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetUnicodeDeviceAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
 
   adapter->AddMockDevice(GetBaseDevice(adapter.get(), "❤❤❤❤❤❤❤❤❤"));
 
-  return adapter.Pass();
+  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());
   FOR_EACH_OBSERVER(BluetoothAdapter::Observer, adapter->GetObservers(),
                     DeviceAdded(adapter.get(), new_device_ptr));
@@ skipping 23 matching lines @@
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetMissingServiceHeartRateAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
 
   adapter->AddMockDevice(GetHeartRateDevice(adapter.get()));
 
-  return adapter.Pass();
+  return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetMissingCharacteristicHeartRateAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
 
   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());
 
-  return adapter.Pass();
+  return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetDelayedServicesDiscoveryAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
   scoped_ptr<NiceMockBluetoothDevice> device(GetHeartRateDevice(adapter.get()));
 
   MockBluetoothAdapter* adapter_ptr = adapter.get();
   MockBluetoothDevice* device_ptr = device.get();
@@ skipping 24 matching lines @@
         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());
 
-  return adapter.Pass();
+  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());
 
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetFailingConnectionsAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
 
   for (int error = BluetoothDevice::ERROR_UNKNOWN;
        error <= BluetoothDevice::ERROR_UNSUPPORTED_DEVICE; error++) {
     adapter->AddMockDevice(GetUnconnectableDevice(
         adapter.get(), static_cast<BluetoothDevice::ConnectErrorCode>(error)));
   }
 
-  return adapter.Pass();
+  return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetFailingGATTOperationsAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
 
   const std::string errorsServiceUUID = errorUUID(0xA0);
 
   BluetoothDevice::UUIDList uuids;
   uuids.push_back(BluetoothUUID(errorsServiceUUID));
 
   scoped_ptr<NiceMockBluetoothDevice> device(
       GetConnectableDevice(adapter.get(), "Errors Device", uuids));
 
   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());
 
-  return adapter.Pass();
+  return adapter;
 }
 
 // Discovery Sessions
 
 // static
 scoped_ptr<NiceMockBluetoothDiscoverySession>
 LayoutTestBluetoothAdapterProvider::GetDiscoverySession() {
   scoped_ptr<NiceMockBluetoothDiscoverySession> discovery_session(
       new NiceMockBluetoothDiscoverySession());
 
   ON_CALL(*discovery_session, Stop(_, _))
       .WillByDefault(RunCallback<0 /* success_callback */>());
 
-  return discovery_session.Pass();
+  return discovery_session;
 }
 
 // Devices
 
 // static
 scoped_ptr<NiceMockBluetoothDevice>
 LayoutTestBluetoothAdapterProvider::GetBaseDevice(
     MockBluetoothAdapter* adapter,
     const std::string& device_name,
     device::BluetoothDevice::UUIDList uuids,
@@ skipping 17 matching lines @@
   ON_CALL(*device, GetGattService(_))
       .WillByDefault(
           Invoke(device.get(), &MockBluetoothDevice::GetMockService));
 
   ON_CALL(*device, GetVendorIDSource())
       .WillByDefault(Return(BluetoothDevice::VENDOR_ID_BLUETOOTH));
   ON_CALL(*device, GetVendorID()).WillByDefault(Return(0xFFFF));
   ON_CALL(*device, GetProductID()).WillByDefault(Return(1));
   ON_CALL(*device, GetDeviceID()).WillByDefault(Return(2));
 
-  return device.Pass();
+  return device;
 }
 
 // static
 scoped_ptr<NiceMockBluetoothDevice>
 LayoutTestBluetoothAdapterProvider::GetBatteryDevice(
     MockBluetoothAdapter* adapter) {
   BluetoothDevice::UUIDList uuids;
   uuids.push_back(BluetoothUUID(kBatteryServiceUUID));
 
   return GetBaseDevice(adapter, "Battery Device", uuids, makeMACAddress(0x1));
@@ skipping 25 matching lines @@
   ON_CALL(*device, CreateGattConnection(_, _))
       .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
           [adapter, device_ptr]() {
             base::ThreadTaskRunnerHandle::Get()->PostTask(
                 FROM_HERE, base::Bind(&NotifyServicesDiscovered,
                                       make_scoped_refptr(adapter), device_ptr));
             return make_scoped_ptr(new NiceMockBluetoothGattConnection(
                 adapter, device_ptr->GetAddress()));
           }));
 
-  return device.Pass();
+  return device;
 }
 
 // static
 scoped_ptr<NiceMockBluetoothDevice>
 LayoutTestBluetoothAdapterProvider::GetUnconnectableDevice(
     MockBluetoothAdapter* adapter,
     BluetoothDevice::ConnectErrorCode error_code,
     const std::string& device_name) {
   BluetoothDevice::UUIDList uuids;
   uuids.push_back(BluetoothUUID(errorUUID(error_code)));
 
   scoped_ptr<NiceMockBluetoothDevice> device(
       GetBaseDevice(adapter, device_name, uuids, makeMACAddress(error_code)));
 
   ON_CALL(*device, CreateGattConnection(_, _))
       .WillByDefault(RunCallback<1 /* error_callback */>(error_code));
 
-  return device.Pass();
+  return device;
 }
 
 // static
 scoped_ptr<NiceMockBluetoothDevice>
 LayoutTestBluetoothAdapterProvider::GetHeartRateDevice(
     MockBluetoothAdapter* adapter) {
   BluetoothDevice::UUIDList uuids;
   uuids.push_back(BluetoothUUID(kHeartRateServiceUUID));
 
   return GetConnectableDevice(adapter, "Heart Rate Device", uuids);
@@ skipping 12 matching lines @@
           true /* is_primary */, false /* is_local */));
 
   ON_CALL(*service, GetCharacteristics())
       .WillByDefault(Invoke(service.get(),
                             &MockBluetoothGattService::GetMockCharacteristics));
 
   ON_CALL(*service, GetCharacteristic(_))
       .WillByDefault(Invoke(service.get(),
                             &MockBluetoothGattService::GetMockCharacteristic));
 
-  return service.Pass();
+  return service;
 }
 
 // static
 scoped_ptr<NiceMockBluetoothGattService>
 LayoutTestBluetoothAdapterProvider::GetGenericAccessService(
     MockBluetoothAdapter* adapter,
     MockBluetoothDevice* device) {
   scoped_ptr<NiceMockBluetoothGattService> generic_access(
       GetBaseGATTService(device, kGenericAccessServiceUUID));
 
@@ skipping 40 matching lines @@
           [adapter, measurement_ptr]() {
             scoped_ptr<NiceMockBluetoothGattNotifySession> notify_session(
                 GetBaseGATTNotifySession(measurement_ptr->GetIdentifier()));
 
             std::vector<uint8_t> rate(1 /* size */);
             rate[0] = 60;
 
             notify_session->StartTestNotifications(adapter, measurement_ptr,
                                                    rate);
 
-            return notify_session.Pass();
+            return notify_session;
           }));
 
   // Body Sensor Location Characteristic
   scoped_ptr<NiceMockBluetoothGattCharacteristic> body_sensor_location(
       GetBaseGATTCharacteristic(heart_rate.get(), kBodySensorLocation,
                                 BluetoothGattCharacteristic::PROPERTY_READ));
   BluetoothGattCharacteristic* location_ptr = body_sensor_location.get();
 
   ON_CALL(*body_sensor_location, ReadRemoteCharacteristic(_, _))
       .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
@@ skipping 48 matching lines @@
       .WillByDefault(RunCallback<1 /* error_callback */>(error_code));
 
   // Write response.
   ON_CALL(*characteristic, WriteRemoteCharacteristic(_, _, _))
       .WillByDefault(RunCallback<2 /* error_callback */>(error_code));
 
   // StartNotifySession response
   ON_CALL(*characteristic, StartNotifySession(_, _))
       .WillByDefault(RunCallback<1 /* error_callback */>(error_code));
 
-  return characteristic.Pass();
+  return characteristic;
 }
 
 // Notify sessions
 
 // static
 scoped_ptr<NiceMockBluetoothGattNotifySession>
 LayoutTestBluetoothAdapterProvider::GetBaseGATTNotifySession(
     const std::string& characteristic_identifier) {
   scoped_ptr<NiceMockBluetoothGattNotifySession> session(
       new NiceMockBluetoothGattNotifySession(characteristic_identifier));
 
   ON_CALL(*session, Stop(_))
       .WillByDefault(testing::DoAll(
           InvokeWithoutArgs(
               session.get(),
               &MockBluetoothGattNotifySession::StopTestNotifications),
           RunCallback<0>()));
 
-  return session.Pass();
+  return session;
 }
 
 // Helper functions
 
 // static
 std::string LayoutTestBluetoothAdapterProvider::errorUUID(uint32_t alias) {
   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