Convert device to std::unique_ptr

device/usb/webusb_descriptors.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 "device/usb/webusb_descriptors.h"
 
 #include <stddef.h>
 
 #include <iterator>
 #include <map>
+#include <memory>
 #include <set>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "components/device_event_log/device_event_log.h"
 #include "device/usb/usb_device_handle.h"
 #include "net/base/io_buffer.h"
@@ skipping 19 matching lines @@
 const uint8_t kGetUrlRequest = 0x02;
 
 const uint8_t kWebUsbCapabilityUUID[16] = {
     // Little-endian encoding of {3408b638-09a9-47a0-8bfd-a0768815b665}.
     0x38, 0xB6, 0x08, 0x34, 0xA9, 0x09, 0xA0, 0x47,
     0x8B, 0xFD, 0xA0, 0x76, 0x88, 0x15, 0xB6, 0x65};
 
 const int kControlTransferTimeout = 60000;  // 1 minute
 
 using ReadWebUsbDescriptorsCallback =
-    base::Callback<void(scoped_ptr<WebUsbAllowedOrigins> allowed_origins,
+    base::Callback<void(std::unique_ptr<WebUsbAllowedOrigins> allowed_origins,
                         const GURL& landing_page)>;
 
 using ReadWebUsbAllowedOriginsCallback =
-    base::Callback<void(scoped_ptr<WebUsbAllowedOrigins> allowed_origins)>;
+    base::Callback<void(std::unique_ptr<WebUsbAllowedOrigins> allowed_origins)>;
 
 // Parses a WebUSB Function Subset Header:
 // http://wicg.github.io/webusb/#dfn-function-subset-header
 //
 //  0                   1                   2                   3
 //  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 // |    length     |     type      | 1st interface |   origin[0]   |
 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 // |    origin[1]  |      ...
@@ skipping 80 matching lines @@
   for (size_t i = 0; i < num_functions; ++i) {
     WebUsbFunctionSubset function;
     if (!ParseFunction(&function, it, end))
       return false;
     configuration->functions.push_back(function);
   }
 
   return true;
 }
 
-void OnDoneReadingUrls(scoped_ptr<WebUsbAllowedOrigins> allowed_origins,
+void OnDoneReadingUrls(std::unique_ptr<WebUsbAllowedOrigins> allowed_origins,
                        uint8_t landing_page_id,
-                       scoped_ptr<std::map<uint8_t, GURL>> url_map,
+                       std::unique_ptr<std::map<uint8_t, GURL>> url_map,
                        const ReadWebUsbDescriptorsCallback& callback) {
   for (uint8_t origin_id : allowed_origins->origin_ids) {
     const auto& it = url_map->find(origin_id);
     if (it != url_map->end())
       allowed_origins->origins.push_back(it->second.GetOrigin());
   }
 
   for (auto& configuration : allowed_origins->configurations) {
     for (uint8_t origin_id : configuration.origin_ids) {
       const auto& it = url_map->find(origin_id);
@@ skipping 52 matching lines @@
       kControlTransferTimeout,
       base::Bind(&OnReadUrlDescriptor, url_map, index, callback));
 }
 
 // Reads URL descriptors from the device so that it can fill |allowed_origins|
 // with the GURLs matching the indicies already collected.
 void ReadUrlDescriptors(scoped_refptr<UsbDeviceHandle> device_handle,
                         uint8_t vendor_code,
                         uint8_t landing_page_id,
                         const ReadWebUsbDescriptorsCallback& callback,
-                        scoped_ptr<WebUsbAllowedOrigins> allowed_origins) {
+                        std::unique_ptr<WebUsbAllowedOrigins> allowed_origins) {
   if (!allowed_origins) {
     callback.Run(nullptr, GURL());
     return;
   }
 
   std::set<uint8_t> to_request;
   if (landing_page_id != 0)
     to_request.insert(landing_page_id);
 
   to_request.insert(allowed_origins->origin_ids.begin(),
                     allowed_origins->origin_ids.end());
   for (auto& config : allowed_origins->configurations) {
     to_request.insert(config.origin_ids.begin(), config.origin_ids.end());
     for (auto& function : config.functions) {
       to_request.insert(function.origin_ids.begin(), function.origin_ids.end());
     }
   }
 
-  scoped_ptr<std::map<uint8_t, GURL>> url_map(new std::map<uint8_t, GURL>());
+  std::unique_ptr<std::map<uint8_t, GURL>> url_map(
+      new std::map<uint8_t, GURL>());
   std::map<uint8_t, GURL>* url_map_ptr = url_map.get();
   base::Closure barrier = base::BarrierClosure(
       static_cast<int>(to_request.size()),
       base::Bind(&OnDoneReadingUrls, base::Passed(&allowed_origins),
                  landing_page_id, base::Passed(&url_map), callback));
 
   for (uint8_t index : to_request) {
     ReadUrlDescriptor(device_handle, vendor_code, url_map_ptr, index, barrier);
   }
 }
 
 void OnReadWebUsbAllowedOrigins(
     const ReadWebUsbAllowedOriginsCallback& callback,
     UsbTransferStatus status,
     scoped_refptr<net::IOBuffer> buffer,
     size_t length) {
   if (status != USB_TRANSFER_COMPLETED) {
     USB_LOG(EVENT) << "Failed to read WebUSB allowed origins.";
     callback.Run(nullptr);
     return;
   }
 
-  scoped_ptr<WebUsbAllowedOrigins> allowed_origins(new WebUsbAllowedOrigins());
+  std::unique_ptr<WebUsbAllowedOrigins> allowed_origins(
+      new WebUsbAllowedOrigins());
   if (allowed_origins->Parse(
           std::vector<uint8_t>(buffer->data(), buffer->data() + length))) {
     callback.Run(std::move(allowed_origins));
   } else {
     callback.Run(nullptr);
   }
 }
 
 void OnReadWebUsbAllowedOriginsHeader(
     scoped_refptr<UsbDeviceHandle> device_handle,
@@ skipping 302 matching lines @@
     for (const auto& function : config.functions) {
       if (ContainsValue(function.origins, origin))
         return true;
     }
   }
 
   return false;
 }
 
 }  // namespace device