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

extensions/browser/api/hid/hid_device_manager.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 "extensions/browser/api/hid/hid_device_manager.h"
 
 #include <stdint.h>
 
 #include <limits>
 #include <utility>
 #include <vector>
 
 #include "base/lazy_instance.h"
+#include "base/memory/ptr_util.h"
 #include "device/core/device_client.h"
 #include "device/hid/hid_device_filter.h"
 #include "device/hid/hid_service.h"
 #include "extensions/browser/api/device_permissions_manager.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/permissions/usb_device_permission.h"
 
 namespace hid = extensions::api::hid;
 
 using device::HidDeviceFilter;
@@ skipping 90 matching lines @@
 }
 
 void HidDeviceManager::GetApiDevices(
     const Extension* extension,
     const std::vector<HidDeviceFilter>& filters,
     const GetApiDevicesCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   LazyInitialize();
 
   if (enumeration_ready_) {
-    scoped_ptr<base::ListValue> devices =
+    std::unique_ptr<base::ListValue> devices =
         CreateApiDeviceList(extension, filters);
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, base::Passed(&devices)));
   } else {
-    pending_enumerations_.push_back(
-        make_scoped_ptr(new GetApiDevicesParams(extension, filters, callback)));
+    pending_enumerations_.push_back(base::WrapUnique(
+        new GetApiDevicesParams(extension, filters, callback)));
   }
 }
 
-scoped_ptr<base::ListValue> HidDeviceManager::GetApiDevicesFromList(
+std::unique_ptr<base::ListValue> HidDeviceManager::GetApiDevicesFromList(
     const std::vector<scoped_refptr<HidDeviceInfo>>& devices) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  scoped_ptr<base::ListValue> device_list(new base::ListValue());
+  std::unique_ptr<base::ListValue> device_list(new base::ListValue());
   for (const auto& device : devices) {
     const auto device_entry = resource_ids_.find(device->device_id());
     DCHECK(device_entry != resource_ids_.end());
 
     hid::HidDeviceInfo device_info;
     device_info.device_id = device_entry->second;
     PopulateHidDeviceInfo(&device_info, device);
     device_list->Append(device_info.ToValue().release());
   }
   return device_list;
@@ skipping 69 matching lines @@
   resource_ids_[device_info->device_id()] = new_id;
   device_ids_[new_id] = device_info->device_id();
 
   // Don't generate events during the initial enumeration.
   if (enumeration_ready_ && event_router_) {
     api::hid::HidDeviceInfo api_device_info;
     api_device_info.device_id = new_id;
     PopulateHidDeviceInfo(&api_device_info, device_info);
 
     if (api_device_info.collections.size() > 0) {
-      scoped_ptr<base::ListValue> args(
+      std::unique_ptr<base::ListValue> args(
           hid::OnDeviceAdded::Create(api_device_info));
       DispatchEvent(events::HID_ON_DEVICE_ADDED, hid::OnDeviceAdded::kEventName,
                     std::move(args), device_info);
     }
   }
 }
 
 void HidDeviceManager::OnDeviceRemoved(
     scoped_refptr<HidDeviceInfo> device_info) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const auto& resource_entry = resource_ids_.find(device_info->device_id());
   DCHECK(resource_entry != resource_ids_.end());
   int resource_id = resource_entry->second;
   const auto& device_entry = device_ids_.find(resource_id);
   DCHECK(device_entry != device_ids_.end());
   resource_ids_.erase(resource_entry);
   device_ids_.erase(device_entry);
 
   if (event_router_) {
     DCHECK(enumeration_ready_);
-    scoped_ptr<base::ListValue> args(hid::OnDeviceRemoved::Create(resource_id));
+    std::unique_ptr<base::ListValue> args(
+        hid::OnDeviceRemoved::Create(resource_id));
     DispatchEvent(events::HID_ON_DEVICE_REMOVED,
                   hid::OnDeviceRemoved::kEventName, std::move(args),
                   device_info);
   }
 }
 
 void HidDeviceManager::LazyInitialize() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (initialized_) {
     return;
   }
 
   HidService* hid_service = device::DeviceClient::Get()->GetHidService();
   DCHECK(hid_service);
   hid_service->GetDevices(base::Bind(&HidDeviceManager::OnEnumerationComplete,
                                      weak_factory_.GetWeakPtr()));
 
   hid_service_observer_.Add(hid_service);
   initialized_ = true;
 }
 
-scoped_ptr<base::ListValue> HidDeviceManager::CreateApiDeviceList(
+std::unique_ptr<base::ListValue> HidDeviceManager::CreateApiDeviceList(
     const Extension* extension,
     const std::vector<HidDeviceFilter>& filters) {
   HidService* hid_service = device::DeviceClient::Get()->GetHidService();
   DCHECK(hid_service);
 
-  scoped_ptr<base::ListValue> api_devices(new base::ListValue());
+  std::unique_ptr<base::ListValue> api_devices(new base::ListValue());
   for (const ResourceIdToDeviceIdMap::value_type& map_entry : device_ids_) {
     int resource_id = map_entry.first;
     const HidDeviceId& device_id = map_entry.second;
 
     scoped_refptr<HidDeviceInfo> device_info =
         hid_service->GetDeviceInfo(device_id);
     if (!device_info) {
       continue;
     }
 
@@ skipping 22 matching lines @@
 void HidDeviceManager::OnEnumerationComplete(
     const std::vector<scoped_refptr<HidDeviceInfo>>& devices) {
   DCHECK(resource_ids_.empty());
   DCHECK(device_ids_.empty());
   for (const scoped_refptr<HidDeviceInfo>& device_info : devices) {
     OnDeviceAdded(device_info);
   }
   enumeration_ready_ = true;
 
   for (const auto& params : pending_enumerations_) {
-    scoped_ptr<base::ListValue> devices =
+    std::unique_ptr<base::ListValue> devices =
         CreateApiDeviceList(params->extension, params->filters);
     params->callback.Run(std::move(devices));
   }
   pending_enumerations_.clear();
 }
 
-void HidDeviceManager::DispatchEvent(events::HistogramValue histogram_value,
-                                     const std::string& event_name,
-                                     scoped_ptr<base::ListValue> event_args,
-                                     scoped_refptr<HidDeviceInfo> device_info) {
-  scoped_ptr<Event> event(
+void HidDeviceManager::DispatchEvent(
+    events::HistogramValue histogram_value,
+    const std::string& event_name,
+    std::unique_ptr<base::ListValue> event_args,
+    scoped_refptr<HidDeviceInfo> device_info) {
+  std::unique_ptr<Event> event(
       new Event(histogram_value, event_name, std::move(event_args)));
   event->will_dispatch_callback = base::Bind(
       &WillDispatchDeviceEvent, weak_factory_.GetWeakPtr(), device_info);
   event_router_->BroadcastEvent(std::move(event));
 }
 
 }  // namespace extensions