Re-write many calls to WrapUnique() with MakeUnique()

components/proximity_auth/ble/bluetooth_low_energy_connection_unittest.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 "components/proximity_auth/ble/bluetooth_low_energy_connection.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
@@ skipping 121 matching lines @@
         remote_device_(CreateLERemoteDeviceForTest()),
         service_uuid_(device::BluetoothUUID(kServiceUUID)),
         to_peripheral_char_uuid_(device::BluetoothUUID(kToPeripheralCharUUID)),
         from_peripheral_char_uuid_(
             device::BluetoothUUID(kFromPeripheralCharUUID)),
         notify_session_alias_(NULL),
         bluetooth_throttler_(new NiceMock<MockBluetoothThrottler>),
         task_runner_(new base::TestSimpleTaskRunner) {}
 
   void SetUp() override {
-    device_ = base::WrapUnique(new NiceMock<device::MockBluetoothDevice>(
+    device_ = base::MakeUnique<NiceMock<device::MockBluetoothDevice>>(
         adapter_.get(), 0, kTestRemoteDeviceName,
-        kTestRemoteDeviceBluetoothAddress, false, false));
+        kTestRemoteDeviceBluetoothAddress, false, false);
 
-    service_ = base::WrapUnique(new NiceMock<device::MockBluetoothGattService>(
-        device_.get(), kServiceID, service_uuid_, true, false));
+    service_ = base::MakeUnique<NiceMock<device::MockBluetoothGattService>>(
+        device_.get(), kServiceID, service_uuid_, true, false);
     to_peripheral_char_ =
-        base::WrapUnique(new NiceMock<device::MockBluetoothGattCharacteristic>(
+        base::MakeUnique<NiceMock<device::MockBluetoothGattCharacteristic>>(
             service_.get(), kToPeripheralCharID, to_peripheral_char_uuid_,
             false, kCharacteristicProperties,
-            device::BluetoothRemoteGattCharacteristic::PERMISSION_NONE));
+            device::BluetoothRemoteGattCharacteristic::PERMISSION_NONE);
 
     from_peripheral_char_ =
-        base::WrapUnique(new NiceMock<device::MockBluetoothGattCharacteristic>(
+        base::MakeUnique<NiceMock<device::MockBluetoothGattCharacteristic>>(
             service_.get(), kFromPeripheralCharID, from_peripheral_char_uuid_,
             false, kCharacteristicProperties,
-            device::BluetoothRemoteGattCharacteristic::PERMISSION_NONE));
+            device::BluetoothRemoteGattCharacteristic::PERMISSION_NONE);
 
     device::BluetoothAdapterFactory::SetAdapterForTesting(adapter_);
 
     std::vector<const device::BluetoothDevice*> devices;
     devices.push_back(device_.get());
     ON_CALL(*adapter_, GetDevices()).WillByDefault(Return(devices));
     ON_CALL(*adapter_, GetDevice(kTestRemoteDeviceBluetoothAddress))
         .WillByDefault(Return(device_.get()));
     ON_CALL(*device_, GetGattService(kServiceID))
         .WillByDefault(Return(service_.get()));
@@ skipping 44 matching lines @@
     // Preparing |connection| to run |create_gatt_connection_success_callback_|.
     EXPECT_FALSE(create_gatt_connection_error_callback_.is_null());
     ASSERT_FALSE(create_gatt_connection_success_callback_.is_null());
     EXPECT_CALL(*connection, CreateCharacteristicsFinder(_, _))
         .WillOnce(DoAll(
             SaveArg<0>(&characteristics_finder_success_callback_),
             SaveArg<1>(&characteristics_finder_error_callback_),
             Return(new NiceMock<MockBluetoothLowEnergyCharacteristicsFinder>)));
 
     create_gatt_connection_success_callback_.Run(
-        base::WrapUnique(new NiceMock<device::MockBluetoothGattConnection>(
-            adapter_, kTestRemoteDeviceBluetoothAddress)));
+        base::MakeUnique<NiceMock<device::MockBluetoothGattConnection>>(
+            adapter_, kTestRemoteDeviceBluetoothAddress));
 
     EXPECT_EQ(connection->sub_status(),
               BluetoothLowEnergyConnection::SubStatus::WAITING_CHARACTERISTICS);
     EXPECT_EQ(connection->status(), Connection::IN_PROGRESS);
   }
 
   // Transitions |connection| from WAITING_CHARACTERISTICS to
   // WAITING_NOTIFY_SESSION state.
   void CharacteristicsFound(MockBluetoothLowEnergyConnection* connection) {
     EXPECT_CALL(*from_peripheral_char_, StartNotifySession(_, _))
@@ skipping 356 matching lines @@
   EXPECT_CALL(*to_peripheral_char_, WriteRemoteCharacteristic(_, _, _))
       .WillOnce(
           DoAll(SaveArg<0>(&last_value_written_on_to_peripheral_char_),
                 SaveArg<1>(&write_remote_characteristic_success_callback_),
                 SaveArg<2>(&write_remote_characteristic_error_callback_)));
 
   // Message (bytes) that is going to be sent.
   int message_size = 100;
   std::string message(message_size, 'A');
   message[0] = 'B';
-  connection->SendMessage(base::WrapUnique(new FakeWireMessage(message)));
+  connection->SendMessage(base::MakeUnique<FakeWireMessage>(message));
 
   // Expecting that |kSendSignal| + |message_size| + |message| was written.
   EXPECT_EQ(last_value_written_on_to_peripheral_char_,
             CreateFirstCharacteristicValue(message, message.size()));
   EXPECT_CALL(*connection, OnDidSendMessage(_, _));
 
   RunWriteCharacteristicSuccessCallback();
 }
 
 TEST_F(ProximityAuthBluetoothLowEnergyConnectionTest,
        SendMessage_LagerThanCharacteristicSize) {
   std::unique_ptr<MockBluetoothLowEnergyConnection> connection(
       CreateConnection());
   InitializeConnection(connection.get());
 
   // Expecting a first call of WriteRemoteCharacteristic, after SendMessage is
   // called.
   EXPECT_CALL(*to_peripheral_char_, WriteRemoteCharacteristic(_, _, _))
       .WillOnce(
           DoAll(SaveArg<0>(&last_value_written_on_to_peripheral_char_),
                 SaveArg<1>(&write_remote_characteristic_success_callback_),
                 SaveArg<2>(&write_remote_characteristic_error_callback_)));
 
   // Message (bytes) that is going to be sent.
   int message_size = 600;
   std::string message(message_size, 'A');
   message[0] = 'B';
-  connection->SendMessage(base::WrapUnique(new FakeWireMessage(message)));
+  connection->SendMessage(base::MakeUnique<FakeWireMessage>(message));
 
   // Expecting that |kSendSignal| + |message_size| was written in the first 8
   // bytes.
   std::vector<uint8_t> prefix(
       last_value_written_on_to_peripheral_char_.begin(),
       last_value_written_on_to_peripheral_char_.begin() + 8);
   EXPECT_EQ(prefix, CreateSendSignalWithSize(message_size));
   std::vector<uint8_t> bytes_received(
       last_value_written_on_to_peripheral_char_.begin() + 8,
       last_value_written_on_to_peripheral_char_.end());
@@ skipping 45 matching lines @@
   ASSERT_FALSE(create_gatt_connection_success_callback_.is_null());
 
   // Preparing |connection| to run |create_gatt_connection_success_callback_|.
   EXPECT_CALL(*connection, CreateCharacteristicsFinder(_, _))
       .WillOnce(DoAll(
           SaveArg<0>(&characteristics_finder_success_callback_),
           SaveArg<1>(&characteristics_finder_error_callback_),
           Return(new NiceMock<MockBluetoothLowEnergyCharacteristicsFinder>)));
 
   create_gatt_connection_success_callback_.Run(
-      base::WrapUnique(new NiceMock<device::MockBluetoothGattConnection>(
-          adapter_, kTestRemoteDeviceBluetoothAddress)));
+      base::MakeUnique<NiceMock<device::MockBluetoothGattConnection>>(
+          adapter_, kTestRemoteDeviceBluetoothAddress));
 
   CharacteristicsFound(connection.get());
   NotifySessionStarted(connection.get());
   ResponseSignalReceived(connection.get());
 }
 
 }  // namespace proximity_auth