Convert device to std::unique_ptr

device/serial/serial_device_enumerator_win.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 "device/serial/serial_device_enumerator_win.h"
 
-#include <windows.h>
-
 #include <devguid.h>
 #include <setupapi.h>
 #include <stdint.h>
+#include <windows.h>
 
-#include "base/memory/scoped_ptr.h"
+#include <memory>
+
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/registry.h"
 #include "third_party/re2/src/re2/re2.h"
 
 namespace device {
 
 namespace {
 
 // Searches the specified device info for a property with the specified key,
 // assigns the result to value, and returns whether the operation was
 // successful.
 bool GetProperty(HDEVINFO dev_info,
                  SP_DEVINFO_DATA dev_info_data,
                  const int key,
                  std::string* value) {
   // We don't know how much space the property's value will take up, so we call
   // the property retrieval function once to fetch the size of the required
   // value buffer, then again once we've allocated a sufficiently large buffer.
   DWORD buffer_size = 0;
   SetupDiGetDeviceRegistryProperty(dev_info, &dev_info_data, key, nullptr,
                                    nullptr, buffer_size, &buffer_size);
   if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
     return false;
 
-  scoped_ptr<wchar_t[]> buffer(new wchar_t[buffer_size]);
+  std::unique_ptr<wchar_t[]> buffer(new wchar_t[buffer_size]);
   if (!SetupDiGetDeviceRegistryProperty(dev_info, &dev_info_data, key, nullptr,
                                         reinterpret_cast<PBYTE>(buffer.get()),
                                         buffer_size, nullptr))
     return false;
 
   *value = base::WideToUTF8(buffer.get());
   return true;
 }
 
 // Searches for the COM port in the device's friendly name, assigns its value to
@@ skipping 94 matching lines @@
     serial::DeviceInfoPtr info(serial::DeviceInfo::New());
     info->path = base::UTF16ToASCII(iter_key.Value());
     devices.push_back(std::move(info));
   }
   return devices;
 }
 
 }  // namespace
 
 // static
-scoped_ptr<SerialDeviceEnumerator> SerialDeviceEnumerator::Create() {
-  return scoped_ptr<SerialDeviceEnumerator>(new SerialDeviceEnumeratorWin());
+std::unique_ptr<SerialDeviceEnumerator> SerialDeviceEnumerator::Create() {
+  return std::unique_ptr<SerialDeviceEnumerator>(
+      new SerialDeviceEnumeratorWin());
 }
 
 SerialDeviceEnumeratorWin::SerialDeviceEnumeratorWin() {}
 
 SerialDeviceEnumeratorWin::~SerialDeviceEnumeratorWin() {}
 
 mojo::Array<serial::DeviceInfoPtr> SerialDeviceEnumeratorWin::GetDevices() {
   mojo::Array<serial::DeviceInfoPtr> newDevices = GetDevicesNew();
   mojo::Array<serial::DeviceInfoPtr> oldDevices = GetDevicesOld();
 
@@ skipping 15 matching lines @@
   }
 
   mojo::Array<mojo::String> paths;
   mojo::Array<serial::DeviceInfoPtr> devices;
   deviceMap.DecomposeMapTo(&paths, &devices);
 
   return devices;
 }
 
 }  // namespace device