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

A mostly-automated change to convert instances of WrapUnique(new Foo(...)) to
MakeUnique<Foo>(...). See the thread at
https://groups.google.com/a/chromium.org/forum/#!topic/chromium-dev/iQgMedVA8-k
for background.

To avoid requiring too many manual fixups, the change skips some cases that are
frequently problematic. In particular, in methods named Foo::Method() it will
not try to change WrapUnique(new Foo()) to MakeUnique<Foo>(). This is because
Foo::Method() may be accessing an internal constructor of Foo.

Cases where MakeUnique<NestedClass>(...) is called within a method of
OuterClass are common but hard to detect automatically, so have been fixed-up
manually.

The only types of manual fix ups applied are:
1) Revert MakeUnique back to WrapUnique
2) Change NULL to nullptr in argument list (MakeUnique cannot forward NULL
   correctly)
3) Add base:: namespace qualifier where missing.

WrapUnique(new Foo) has not been converted to MakeUnique<Foo>() as this might
change behaviour if Foo does not have a user-defined constructor. For example,
WrapUnique(new int) creates an unitialised integer, but MakeUnique<int>()
creates an integer initialised to 0.

git cl format has been been run over the CL. Spot-checking has uncovered no
cases of mis-formatting.

  BUG=637812

Review-Url: https://codereview.chromium.org/2254833003
Cr-Commit-Position: refs/heads/master@{#414312}

device/bluetooth/bluetooth_advertisement_unittest.cc

@@ -34,7 +34,7 @@ TEST(BluetoothAdvertisementTest, DataMembersAreAssignedCorrectly) {
   ASSERT_FALSE(data.service_uuids().get());
   // Assign Service UUID.
   data.set_service_uuids(
-      base::WrapUnique(new BluetoothAdvertisement::UUIDList(uuids)));
+      base::MakeUnique<BluetoothAdvertisement::UUIDList>(uuids));
   // Retrieve Service UUID.
   ASSERT_EQ(*data.service_uuids(), uuids);
   // Retrieve again.
@@ -43,8 +43,9 @@ TEST(BluetoothAdvertisementTest, DataMembersAreAssignedCorrectly) {
   // Try without assigning Manufacturer Data.
   ASSERT_FALSE(data.manufacturer_data().get());
   // Assign Manufacturer Data.
-  data.set_manufacturer_data(base::WrapUnique(
-      new BluetoothAdvertisement::ManufacturerData(manufacturer_data)));
+  data.set_manufacturer_data(
+      base::MakeUnique<BluetoothAdvertisement::ManufacturerData>(
+          manufacturer_data));
   // Retrieve Manufacturer Data.
   ASSERT_EQ(*data.manufacturer_data(), manufacturer_data);
   // Retrieve again.
@@ -54,7 +55,7 @@ TEST(BluetoothAdvertisementTest, DataMembersAreAssignedCorrectly) {
   ASSERT_FALSE(data.solicit_uuids().get());
   // Assign Solicit UUIDs.
   data.set_solicit_uuids(
-      base::WrapUnique(new BluetoothAdvertisement::UUIDList(uuids)));
+      base::MakeUnique<BluetoothAdvertisement::UUIDList>(uuids));
   // Retrieve Solicit UUIDs.
   ASSERT_EQ(*data.solicit_uuids(), uuids);
   // Retieve again.
@@ -64,7 +65,7 @@ TEST(BluetoothAdvertisementTest, DataMembersAreAssignedCorrectly) {
   ASSERT_FALSE(data.service_data().get());
   // Assign Service Data.
   data.set_service_data(
-      base::WrapUnique(new BluetoothAdvertisement::ServiceData(service_data)));
+      base::MakeUnique<BluetoothAdvertisement::ServiceData>(service_data));
   // Retrieve Service Data.
   ASSERT_EQ(*data.service_data(), service_data);
   // Retrieve again.

device/bluetooth/bluetooth_device.cc

@@ -397,7 +397,7 @@ void BluetoothDevice::ClearAdvertisementData() {
 void BluetoothDevice::DidConnectGatt() {
   for (const auto& callback : create_gatt_connection_success_callbacks_) {
     callback.Run(
-        base::WrapUnique(new BluetoothGattConnection(adapter_, GetAddress())));
+        base::MakeUnique<BluetoothGattConnection>(adapter_, GetAddress()));
   }
   create_gatt_connection_success_callbacks_.clear();
   create_gatt_connection_error_callbacks_.clear();

device/bluetooth/bluetooth_remote_gatt_characteristic_win.cc

@@ -447,8 +447,8 @@ void BluetoothRemoteGattCharacteristicWin::GattEventRegistrationCallback(
   if (SUCCEEDED(hr)) {
     gatt_event_handle_ = event_handle;
     for (const auto& callback : callbacks) {
-      callback.first.Run(base::WrapUnique(
-          new BluetoothGattNotifySession(weak_ptr_factory_.GetWeakPtr())));
+      callback.first.Run(base::MakeUnique<BluetoothGattNotifySession>(
+          weak_ptr_factory_.GetWeakPtr()));
     }
   } else {
     for (const auto& callback : callbacks)

device/bluetooth/bluez/bluetooth_advertisement_bluez_unittest.cc

@@ -98,16 +98,16 @@ class BluetoothAdvertisementBlueZTest : public testing::Test {
 
   std::unique_ptr<BluetoothAdvertisement::Data> CreateAdvertisementData() {
     std::unique_ptr<BluetoothAdvertisement::Data> data =
-        base::WrapUnique(new BluetoothAdvertisement::Data(
-            BluetoothAdvertisement::ADVERTISEMENT_TYPE_BROADCAST));
+        base::MakeUnique<BluetoothAdvertisement::Data>(
+            BluetoothAdvertisement::ADVERTISEMENT_TYPE_BROADCAST);
     data->set_service_uuids(
-        base::WrapUnique(new BluetoothAdvertisement::UUIDList()));
+        base::MakeUnique<BluetoothAdvertisement::UUIDList>());
     data->set_manufacturer_data(
-        base::WrapUnique(new BluetoothAdvertisement::ManufacturerData()));
+        base::MakeUnique<BluetoothAdvertisement::ManufacturerData>());
     data->set_solicit_uuids(
-        base::WrapUnique(new BluetoothAdvertisement::UUIDList()));
+        base::MakeUnique<BluetoothAdvertisement::UUIDList>());
     data->set_service_data(
-        base::WrapUnique(new BluetoothAdvertisement::ServiceData()));
+        base::MakeUnique<BluetoothAdvertisement::ServiceData>());
     return data;
   }
 

device/bluetooth/dbus/bluetooth_gatt_application_service_provider.cc

@@ -116,8 +116,8 @@ void BluetoothGattApplicationServiceProvider::CreateAttributeServiceProviders(
       characteristic_providers_.push_back(
           base::WrapUnique(BluetoothGattCharacteristicServiceProvider::Create(
               bus, characteristic.second->object_path(),
-              base::WrapUnique(new BluetoothGattCharacteristicDelegateWrapper(
-                  service.second, characteristic.second.get())),
+              base::MakeUnique<BluetoothGattCharacteristicDelegateWrapper>(
+                  service.second, characteristic.second.get()),
               characteristic.second->GetUUID().value(),
               FlagsFromProperties(characteristic.second->GetProperties()),
               service.second->object_path())));
@@ -125,8 +125,8 @@ void BluetoothGattApplicationServiceProvider::CreateAttributeServiceProviders(
         descriptor_providers_.push_back(
             base::WrapUnique(BluetoothGattDescriptorServiceProvider::Create(
                 bus, descriptor->object_path(),
-                base::WrapUnique(new BluetoothGattDescriptorDelegateWrapper(
-                    service.second, descriptor.get())),
+                base::MakeUnique<BluetoothGattDescriptorDelegateWrapper>(
+                    service.second, descriptor.get()),
                 descriptor->GetUUID().value(),
                 FlagsFromPermissions(descriptor->GetPermissions()),
                 characteristic.second->object_path())));
@@ -161,8 +161,8 @@ BluetoothGattApplicationServiceProvider::Create(
     return base::WrapUnique(new BluetoothGattApplicationServiceProviderImpl(
         bus, object_path, services));
   }
-  return base::WrapUnique(
-      new FakeBluetoothGattApplicationServiceProvider(object_path, services));
+  return base::MakeUnique<FakeBluetoothGattApplicationServiceProvider>(
+      object_path, services);
 }
 
 }  // namespace bluez

device/bluetooth/dbus/bluetooth_gatt_application_service_provider_unittest.cc

@@ -293,9 +293,9 @@ class BluetoothGattApplicationServiceProviderTest : public testing::Test {
     const std::string& full_service_path =
         std::string(kAppObjectPath) + "/" + service_path;
     app_provider->service_providers_.push_back(
-        base::WrapUnique(new BluetoothGattServiceServiceProviderImpl(
+        base::MakeUnique<BluetoothGattServiceServiceProviderImpl>(
             nullptr, dbus::ObjectPath(full_service_path), kFakeServiceUuid,
-            true, std::vector<dbus::ObjectPath>())));
+            true, std::vector<dbus::ObjectPath>()));
     return full_service_path;
   }
 
@@ -350,9 +350,9 @@ class BluetoothGattApplicationServiceProviderTest : public testing::Test {
 
 TEST_F(BluetoothGattApplicationServiceProviderTest, GetManagedObjects) {
   std::unique_ptr<BluetoothGattApplicationServiceProviderImpl> app_provider =
-      base::WrapUnique(new BluetoothGattApplicationServiceProviderImpl(
+      base::MakeUnique<BluetoothGattApplicationServiceProviderImpl>(
           nullptr, dbus::ObjectPath(kAppObjectPath),
-          std::map<dbus::ObjectPath, BluetoothLocalGattServiceBlueZ*>()));
+          std::map<dbus::ObjectPath, BluetoothLocalGattServiceBlueZ*>());
   CreateFakeAttributes(app_provider.get());
 
   dbus::MethodCall method_call("com.example.Interface", "SomeMethod");
@@ -364,9 +364,9 @@ TEST_F(BluetoothGattApplicationServiceProviderTest, GetManagedObjects) {
 
 TEST_F(BluetoothGattApplicationServiceProviderTest, SendValueChanged) {
   std::unique_ptr<BluetoothGattApplicationServiceProviderImpl> app_provider =
-      base::WrapUnique(new BluetoothGattApplicationServiceProviderImpl(
+      base::MakeUnique<BluetoothGattApplicationServiceProviderImpl>(
           nullptr, dbus::ObjectPath(kAppObjectPath),
-          std::map<dbus::ObjectPath, BluetoothLocalGattServiceBlueZ*>()));
+          std::map<dbus::ObjectPath, BluetoothLocalGattServiceBlueZ*>());
   const std::string& kServicePath =
       CreateFakeService(app_provider.get(), "service0");
   const std::string& kCharacteristicPath = CreateFakeCharacteristic(

device/bluetooth/dbus/bluetooth_le_advertisement_service_provider.cc

@@ -416,13 +416,13 @@ BluetoothLEAdvertisementServiceProvider::Create(
     std::unique_ptr<UUIDList> solicit_uuids,
     std::unique_ptr<ServiceData> service_data) {
   if (!bluez::BluezDBusManager::Get()->IsUsingFakes()) {
-    return base::WrapUnique(new BluetoothAdvertisementServiceProviderImpl(
+    return base::MakeUnique<BluetoothAdvertisementServiceProviderImpl>(
         bus, object_path, delegate, type, std::move(service_uuids),
         std::move(manufacturer_data), std::move(solicit_uuids),
-        std::move(service_data)));
+        std::move(service_data));
   }
-  return base::WrapUnique(
-      new FakeBluetoothLEAdvertisementServiceProvider(object_path, delegate));
+  return base::MakeUnique<FakeBluetoothLEAdvertisementServiceProvider>(
+      object_path, delegate);
 }
 
 }  // namespace bluez

device/bluetooth/test/bluetooth_gatt_server_test.cc

@@ -32,7 +32,7 @@ void BluetoothGattServerTest::SetUp() {
   BluetoothTest::SetUp();
   last_read_value_ = std::vector<uint8_t>();
   InitWithFakeAdapter();
-  delegate_ = base::WrapUnique(new TestBluetoothLocalGattServiceDelegate());
+  delegate_ = base::MakeUnique<TestBluetoothLocalGattServiceDelegate>();
 }
 
 void BluetoothGattServerTest::TearDown() {

device/bluetooth/test/bluetooth_test.cc

@@ -38,7 +38,7 @@ BluetoothTestBase::~BluetoothTestBase() {
 
 void BluetoothTestBase::StartLowEnergyDiscoverySession() {
   adapter_->StartDiscoverySessionWithFilter(
-      base::WrapUnique(new BluetoothDiscoveryFilter(BLUETOOTH_TRANSPORT_LE)),
+      base::MakeUnique<BluetoothDiscoveryFilter>(BLUETOOTH_TRANSPORT_LE),
       GetDiscoverySessionCallback(Call::EXPECTED),
       GetErrorCallback(Call::NOT_EXPECTED));
   base::RunLoop().RunUntilIdle();
@@ -46,7 +46,7 @@ void BluetoothTestBase::StartLowEnergyDiscoverySession() {
 
 void BluetoothTestBase::StartLowEnergyDiscoverySessionExpectedToFail() {
   adapter_->StartDiscoverySessionWithFilter(
-      base::WrapUnique(new BluetoothDiscoveryFilter(BLUETOOTH_TRANSPORT_LE)),
+      base::MakeUnique<BluetoothDiscoveryFilter>(BLUETOOTH_TRANSPORT_LE),
       GetDiscoverySessionCallback(Call::NOT_EXPECTED),
       GetErrorCallback(Call::EXPECTED));
   base::RunLoop().RunUntilIdle();

device/geolocation/geolocation_provider_impl.cc

@@ -191,8 +191,8 @@ GeolocationProviderImpl::CreateArbitrator() {
   if (!g_delegate.Get())
     g_delegate.Get().reset(new GeolocationDelegate);
 
-  return base::WrapUnique(
-      new LocationArbitratorImpl(callback, g_delegate.Get().get()));
+  return base::MakeUnique<LocationArbitratorImpl>(callback,
+                                                  g_delegate.Get().get());
 }
 
 }  // namespace device

device/geolocation/location_arbitrator_impl.cc

@@ -160,8 +160,8 @@ LocationArbitratorImpl::NewNetworkLocationProvider(
   // Android uses its own SystemLocationProvider.
   return nullptr;
 #else
-  return base::WrapUnique(new NetworkLocationProvider(
-      access_token_store, context, url, access_token));
+  return base::MakeUnique<NetworkLocationProvider>(access_token_store, context,
+                                                   url, access_token);
 #endif
 }
 

device/test/usb_test_gadget_impl.cc

@@ -218,8 +218,8 @@ class UsbGadgetFactory : public UsbService::Observer,
   std::unique_ptr<UsbTestGadget> WaitForDevice() {
     EnumerateDevices();
     run_loop_.Run();
-    return base::WrapUnique(
-        new UsbTestGadgetImpl(request_context_getter_, usb_service_, device_));
+    return base::MakeUnique<UsbTestGadgetImpl>(request_context_getter_,
+                                               usb_service_, device_);
   }
 
  private: