Convert //chrome/browser/extensions from scoped_ptr to std::unique_ptr

chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_event_router.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 "chrome/browser/extensions/api/bluetooth_low_energy/bluetooth_low_energy_event_router.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 817 matching lines @@
          service_id_to_device_address_.end());
 
   DCHECK(device->GetAddress() ==
          service_id_to_device_address_[service->GetIdentifier()]);
   service_id_to_device_address_.erase(service->GetIdentifier());
 
   // Signal API event.
   apibtle::Service api_service;
   PopulateService(service, &api_service);
 
-  scoped_ptr<base::ListValue> args =
+  std::unique_ptr<base::ListValue> args =
       apibtle::OnServiceRemoved::Create(api_service);
-  scoped_ptr<Event> event(
+  std::unique_ptr<Event> event(
       new Event(events::BLUETOOTH_LOW_ENERGY_ON_SERVICE_REMOVED,
                 apibtle::OnServiceRemoved::kEventName, std::move(args)));
   EventRouter::Get(browser_context_)->BroadcastEvent(std::move(event));
 }
 
 void BluetoothLowEnergyEventRouter::GattDiscoveryCompleteForService(
     BluetoothAdapter* adapter,
     BluetoothGattService* service) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(adapter, adapter_.get());
   VLOG(2) << "GATT service discovery complete: " << service->GetIdentifier();
 
   DCHECK(service_id_to_device_address_.find(service->GetIdentifier()) !=
          service_id_to_device_address_.end());
 
   // Signal the service added event here.
   apibtle::Service api_service;
   PopulateService(service, &api_service);
 
-  scoped_ptr<base::ListValue> args =
+  std::unique_ptr<base::ListValue> args =
       apibtle::OnServiceAdded::Create(api_service);
-  scoped_ptr<Event> event(
+  std::unique_ptr<Event> event(
       new Event(events::BLUETOOTH_LOW_ENERGY_ON_SERVICE_ADDED,
                 apibtle::OnServiceAdded::kEventName, std::move(args)));
   EventRouter::Get(browser_context_)->BroadcastEvent(std::move(event));
 }
 
 void BluetoothLowEnergyEventRouter::DeviceAddressChanged(
     BluetoothAdapter* adapter,
     BluetoothDevice* device,
     const std::string& old_address) {
   for (auto& iter : service_id_to_device_address_) {
@@ skipping 113 matching lines @@
   DCHECK(chrc_id_to_service_id_.find(characteristic->GetIdentifier()) !=
          chrc_id_to_service_id_.end());
   DCHECK(chrc_id_to_service_id_[characteristic->GetIdentifier()] ==
          service->GetIdentifier());
 
   // Send the event; manually construct the arguments, instead of using
   // apibtle::OnCharacteristicValueChanged::Create, as it doesn't convert
   // lists of enums correctly.
   apibtle::Characteristic api_characteristic;
   PopulateCharacteristic(characteristic, &api_characteristic);
-  scoped_ptr<base::ListValue> args(new base::ListValue());
+  std::unique_ptr<base::ListValue> args(new base::ListValue());
   args->Append(apibtle::CharacteristicToValue(&api_characteristic).release());
 
   DispatchEventToExtensionsWithPermission(
       events::BLUETOOTH_LOW_ENERGY_ON_CHARACTERISTIC_VALUE_CHANGED,
       apibtle::OnCharacteristicValueChanged::kEventName, service->GetUUID(),
       characteristic->GetIdentifier(), std::move(args));
 }
 
 void BluetoothLowEnergyEventRouter::GattDescriptorValueChanged(
     BluetoothAdapter* adapter,
     BluetoothGattDescriptor* descriptor,
     const std::vector<uint8_t>& value) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(adapter, adapter_.get());
   VLOG(2) << "GATT descriptor value changed: " << descriptor->GetIdentifier();
 
   BluetoothGattCharacteristic* characteristic = descriptor->GetCharacteristic();
   DCHECK(characteristic);
 
   DCHECK(desc_id_to_chrc_id_.find(descriptor->GetIdentifier()) !=
          desc_id_to_chrc_id_.end());
   DCHECK(characteristic->GetIdentifier() ==
          desc_id_to_chrc_id_[descriptor->GetIdentifier()]);
 
   // Send the event; manually construct the arguments, instead of using
   // apibtle::OnDescriptorValueChanged::Create, as it doesn't convert
   // lists of enums correctly.
   apibtle::Descriptor api_descriptor;
   PopulateDescriptor(descriptor, &api_descriptor);
-  scoped_ptr<base::ListValue> args(new base::ListValue());
+  std::unique_ptr<base::ListValue> args(new base::ListValue());
   args->Append(apibtle::DescriptorToValue(&api_descriptor).release());
 
   DispatchEventToExtensionsWithPermission(
       events::BLUETOOTH_LOW_ENERGY_ON_DESCRIPTOR_VALUE_CHANGED,
       apibtle::OnDescriptorValueChanged::kEventName,
       characteristic->GetService()->GetUUID(), "" /* characteristic_id */,
       std::move(args));
 }
 
 void BluetoothLowEnergyEventRouter::OnGetAdapter(
@@ skipping 58 matching lines @@
       }
     }
   }
 }
 
 void BluetoothLowEnergyEventRouter::DispatchEventToExtensionsWithPermission(
     events::HistogramValue histogram_value,
     const std::string& event_name,
     const device::BluetoothUUID& uuid,
     const std::string& characteristic_id,
-    scoped_ptr<base::ListValue> args) {
+    std::unique_ptr<base::ListValue> args) {
   // Obtain the listeners of |event_name|. The list can contain multiple
   // entries for the same extension, so we keep track of the extensions that we
   // already sent the event to, since we want the send an event to an extension
   // only once.
   BluetoothPermissionRequest request(uuid.value());
   std::set<std::string> handled_extensions;
   const EventListenerMap::ListenerList listeners =
       EventRouter::Get(browser_context_)->listeners().GetEventListenersByName(
           event_name);
 
@@ skipping 19 matching lines @@
 
     // If |event_name| is "onCharacteristicValueChanged", then send the
     // event only if the extension has requested notifications from the
     // related characteristic.
     if (event_name == apibtle::OnCharacteristicValueChanged::kEventName &&
         !characteristic_id.empty() &&
         !FindNotifySession(extension_id, characteristic_id))
       continue;
 
     // Send the event.
-    scoped_ptr<base::ListValue> args_copy(args->DeepCopy());
-    scoped_ptr<Event> event(
+    std::unique_ptr<base::ListValue> args_copy(args->DeepCopy());
+    std::unique_ptr<Event> event(
         new Event(histogram_value, event_name, std::move(args_copy)));
     EventRouter::Get(browser_context_)
         ->DispatchEventToExtension(extension_id, std::move(event));
   }
 }
 
 BluetoothGattService* BluetoothLowEnergyEventRouter::FindServiceById(
     const std::string& instance_id) const {
   InstanceIdMap::const_iterator iter =
       service_id_to_device_address_.find(instance_id);
@@ skipping 79 matching lines @@
     const std::vector<uint8_t>& value) {
   VLOG(2) << "Remote characteristic/descriptor value read successful.";
   callback.Run();
 }
 
 void BluetoothLowEnergyEventRouter::OnCreateGattConnection(
     bool persistent,
     const std::string& extension_id,
     const std::string& device_address,
     const base::Closure& callback,
-    scoped_ptr<BluetoothGattConnection> connection) {
+    std::unique_ptr<BluetoothGattConnection> connection) {
   VLOG(2) << "GATT connection created.";
   DCHECK(connection.get());
   DCHECK(!FindConnection(extension_id, device_address));
   DCHECK_EQ(device_address, connection->GetDeviceAddress());
 
   const std::string connect_id = extension_id + device_address;
   DCHECK_NE(0U, connecting_devices_.count(connect_id));
 
   BluetoothLowEnergyConnection* conn = new BluetoothLowEnergyConnection(
       persistent, extension_id, std::move(connection));
@@ skipping 78 matching lines @@
   }
 
   error_callback.Run(error_status);
 }
 
 void BluetoothLowEnergyEventRouter::OnStartNotifySession(
     bool persistent,
     const std::string& extension_id,
     const std::string& characteristic_id,
     const base::Closure& callback,
-    scoped_ptr<device::BluetoothGattNotifySession> session) {
+    std::unique_ptr<device::BluetoothGattNotifySession> session) {
   VLOG(2) << "Value update session created for characteristic: "
           << characteristic_id;
   DCHECK(session.get());
   DCHECK(!FindNotifySession(extension_id, characteristic_id));
   DCHECK_EQ(characteristic_id, session->GetCharacteristicIdentifier());
 
   const std::string session_id = extension_id + characteristic_id;
   DCHECK_NE(0U, pending_session_calls_.count(session_id));
 
   BluetoothLowEnergyNotifySession* resource =
@@ skipping 136 matching lines @@
       continue;
 
     manager->Remove(extension_id, *iter);
     return true;
   }
 
   return false;
 }
 
 }  // namespace extensions