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

extensions/browser/api/device_permissions_prompt.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/device_permissions_prompt.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/i18n/message_formatter.h"
@@ skipping 112 matching lines @@
     callback_.Run(devices);
     callback_.Reset();
   }
 
   // device::UsbService::Observer implementation:
   void OnDeviceAdded(scoped_refptr<UsbDevice> device) override {
     if (!(filters_.empty() || UsbDeviceFilter::MatchesAny(device, filters_))) {
       return;
     }
 
-    scoped_ptr<DeviceInfo> device_info(new UsbDeviceInfo(device));
+    std::unique_ptr<DeviceInfo> device_info(new UsbDeviceInfo(device));
     device->CheckUsbAccess(
         base::Bind(&UsbDevicePermissionsPrompt::AddCheckedDevice, this,
                    base::Passed(&device_info)));
   }
 
   void OnDeviceRemoved(scoped_refptr<UsbDevice> device) override {
     for (auto it = devices_.begin(); it != devices_.end(); ++it) {
       const UsbDeviceInfo* entry =
           static_cast<const UsbDeviceInfo*>((*it).get());
       if (entry->device() == device) {
@@ skipping 92 matching lines @@
     }
     DCHECK(multiple() || devices.size() <= 1);
     callback_.Run(devices);
     callback_.Reset();
   }
 
   // device::HidService::Observer implementation:
   void OnDeviceAdded(scoped_refptr<device::HidDeviceInfo> device) override {
     if (HasUnprotectedCollections(device) &&
         (filters_.empty() || HidDeviceFilter::MatchesAny(device, filters_))) {
-      scoped_ptr<DeviceInfo> device_info(new HidDeviceInfo(device));
+      std::unique_ptr<DeviceInfo> device_info(new HidDeviceInfo(device));
 #if defined(OS_CHROMEOS)
       chromeos::PermissionBrokerClient* client =
           chromeos::DBusThreadManager::Get()->GetPermissionBrokerClient();
       DCHECK(client) << "Could not get permission broker client.";
       device::HidDeviceInfoLinux* linux_device_info =
           static_cast<device::HidDeviceInfoLinux*>(device.get());
       client->CheckPathAccess(
           linux_device_info->device_node(),
           base::Bind(&HidDevicePermissionsPrompt::AddCheckedDevice, this,
                      base::Passed(&device_info)));
@@ skipping 79 matching lines @@
 
 void DevicePermissionsPrompt::Prompt::GrantDevicePermission(size_t index) {
   DCHECK_LT(index, devices_.size());
   devices_[index]->set_granted();
 }
 
 DevicePermissionsPrompt::Prompt::~Prompt() {
 }
 
 void DevicePermissionsPrompt::Prompt::AddCheckedDevice(
-    scoped_ptr<DeviceInfo> device,
+    std::unique_ptr<DeviceInfo> device,
     bool allowed) {
   if (allowed) {
     devices_.push_back(std::move(device));
     if (observer_) {
       observer_->OnDevicesChanged();
     }
   }
 }
 
 DevicePermissionsPrompt::DevicePermissionsPrompt(
@@ skipping 38 matching lines @@
 // static
 scoped_refptr<DevicePermissionsPrompt::Prompt>
 DevicePermissionsPrompt::CreateUsbPromptForTest(const Extension* extension,
                                                 bool multiple) {
   return make_scoped_refptr(new UsbDevicePermissionsPrompt(
       extension, nullptr, multiple, std::vector<UsbDeviceFilter>(),
       base::Bind(&NoopUsbCallback)));
 }
 
 }  // namespace extensions