Convert //content/browser from scoped_ptr to std::unique_ptr

content/browser/gamepad/raw_input_data_fetcher_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 "content/browser/gamepad/raw_input_data_fetcher_win.h"
 
 #include <stddef.h>
 
 #include "base/macros.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 44 matching lines @@
   DCHECK(!window_);
   DCHECK(!events_monitored_);
 }
 
 void RawInputDataFetcher::WillDestroyCurrentMessageLoop() {
   StopMonitor();
 }
 
 RAWINPUTDEVICE* RawInputDataFetcher::GetRawInputDevices(DWORD flags) {
   size_t usage_count = arraysize(DeviceUsages);
-  scoped_ptr<RAWINPUTDEVICE[]> devices(new RAWINPUTDEVICE[usage_count]);
+  std::unique_ptr<RAWINPUTDEVICE[]> devices(new RAWINPUTDEVICE[usage_count]);
   for (size_t i = 0; i < usage_count; ++i) {
     devices[i].dwFlags = flags;
     devices[i].usUsagePage = 1;
     devices[i].usUsage = DeviceUsages[i];
     devices[i].hwndTarget = (flags & RIDEV_REMOVE) ? 0 : window_->hwnd();
   }
   return devices.release();
 }
 
 void RawInputDataFetcher::StartMonitor() {
   if (!rawinput_available_ || events_monitored_)
     return;
 
   if (!window_) {
     window_.reset(new base::win::MessageWindow());
     if (!window_->Create(base::Bind(&RawInputDataFetcher::HandleMessage,
                                     base::Unretained(this)))) {
       PLOG(ERROR) << "Failed to create the raw input window";
       window_.reset();
       return;
     }
   }
 
   // Register to receive raw HID input.
-  scoped_ptr<RAWINPUTDEVICE[]> devices(GetRawInputDevices(RIDEV_INPUTSINK));
+  std::unique_ptr<RAWINPUTDEVICE[]> devices(
+      GetRawInputDevices(RIDEV_INPUTSINK));
   if (!RegisterRawInputDevices(devices.get(), arraysize(DeviceUsages),
       sizeof(RAWINPUTDEVICE))) {
     PLOG(ERROR) << "RegisterRawInputDevices() failed for RIDEV_INPUTSINK";
     window_.reset();
     return;
   }
 
   // Start observing message loop destruction if we start monitoring the first
   // event.
   if (!events_monitored_)
     base::MessageLoop::current()->AddDestructionObserver(this);
 
   events_monitored_ = true;
 }
 
 void RawInputDataFetcher::StopMonitor() {
   if (!rawinput_available_ || !events_monitored_)
     return;
 
   // Stop receiving raw input.
   DCHECK(window_);
-  scoped_ptr<RAWINPUTDEVICE[]> devices(GetRawInputDevices(RIDEV_REMOVE));
+  std::unique_ptr<RAWINPUTDEVICE[]> devices(GetRawInputDevices(RIDEV_REMOVE));
 
   if (!RegisterRawInputDevices(devices.get(), arraysize(DeviceUsages),
       sizeof(RAWINPUTDEVICE))) {
     PLOG(INFO) << "RegisterRawInputDevices() failed for RIDEV_REMOVE";
   }
 
   events_monitored_ = false;
   window_.reset();
 
   // Stop observing message loop destruction if no event is being monitored.
@@ skipping 14 matching lines @@
   ClearControllers();
 
   UINT count = 0;
   UINT result = GetRawInputDeviceList(NULL, &count, sizeof(RAWINPUTDEVICELIST));
   if (result == static_cast<UINT>(-1)) {
     PLOG(ERROR) << "GetRawInputDeviceList() failed";
     return valid_controllers;
   }
   DCHECK_EQ(0u, result);
 
-  scoped_ptr<RAWINPUTDEVICELIST[]> device_list(new RAWINPUTDEVICELIST[count]);
+  std::unique_ptr<RAWINPUTDEVICELIST[]> device_list(
+      new RAWINPUTDEVICELIST[count]);
   result = GetRawInputDeviceList(device_list.get(), &count,
       sizeof(RAWINPUTDEVICELIST));
   if (result == static_cast<UINT>(-1)) {
     PLOG(ERROR) << "GetRawInputDeviceList() failed";
     return valid_controllers;
   }
   DCHECK_EQ(count, result);
 
   for (UINT i = 0; i < count; ++i) {
     if (device_list[i].dwType == RIM_TYPEHID) {
@@ skipping 25 matching lines @@
 
   // Query basic device info.
   UINT result = GetRawInputDeviceInfo(hDevice, RIDI_DEVICEINFO,
       NULL, &size);
   if (result == static_cast<UINT>(-1)) {
     PLOG(ERROR) << "GetRawInputDeviceInfo() failed";
     return NULL;
   }
   DCHECK_EQ(0u, result);
 
-  scoped_ptr<uint8_t[]> di_buffer(new uint8_t[size]);
+  std::unique_ptr<uint8_t[]> di_buffer(new uint8_t[size]);
   RID_DEVICE_INFO* device_info =
       reinterpret_cast<RID_DEVICE_INFO*>(di_buffer.get());
   result = GetRawInputDeviceInfo(hDevice, RIDI_DEVICEINFO,
       di_buffer.get(), &size);
   if (result == static_cast<UINT>(-1)) {
     PLOG(ERROR) << "GetRawInputDeviceInfo() failed";
     return NULL;
   }
   DCHECK_EQ(size, result);
 
   // Make sure this device is of a type that we want to observe.
   bool valid_type = false;
   for (USHORT device_usage : DeviceUsages) {
     if (device_info->hid.usUsage == device_usage) {
       valid_type = true;
       break;
     }
   }
 
   if (!valid_type)
     return NULL;
 
-  scoped_ptr<RawGamepadInfo> gamepad_info(new RawGamepadInfo);
+  std::unique_ptr<RawGamepadInfo> gamepad_info(new RawGamepadInfo);
   gamepad_info->handle = hDevice;
   gamepad_info->report_id = 0;
   gamepad_info->vendor_id = device_info->hid.dwVendorId;
   gamepad_info->product_id = device_info->hid.dwProductId;
   gamepad_info->buttons_length = 0;
   ZeroMemory(gamepad_info->buttons, sizeof(gamepad_info->buttons));
   gamepad_info->axes_length = 0;
   ZeroMemory(gamepad_info->axes, sizeof(gamepad_info->axes));
 
   // Query device identifier
   result = GetRawInputDeviceInfo(hDevice, RIDI_DEVICENAME,
       NULL, &size);
   if (result == static_cast<UINT>(-1)) {
     PLOG(ERROR) << "GetRawInputDeviceInfo() failed";
     return NULL;
   }
   DCHECK_EQ(0u, result);
 
-  scoped_ptr<wchar_t[]> name_buffer(new wchar_t[size]);
+  std::unique_ptr<wchar_t[]> name_buffer(new wchar_t[size]);
   result = GetRawInputDeviceInfo(hDevice, RIDI_DEVICENAME,
       name_buffer.get(), &size);
   if (result == static_cast<UINT>(-1)) {
     PLOG(ERROR) << "GetRawInputDeviceInfo() failed";
     return NULL;
   }
   DCHECK_EQ(size, result);
 
   // The presence of "IG_" in the device name indicates that this is an XInput
   // Gamepad. Skip enumerating these devices and let the XInput path handle it.
@@ skipping 34 matching lines @@
   }
   DCHECK_EQ(size, result);
 
   HIDP_CAPS caps;
   NTSTATUS status = hidp_get_caps_(gamepad_info->preparsed_data, &caps);
   DCHECK_EQ(HIDP_STATUS_SUCCESS, status);
 
   // Query button information.
   USHORT count = caps.NumberInputButtonCaps;
   if (count > 0) {
-    scoped_ptr<HIDP_BUTTON_CAPS[]> button_caps(new HIDP_BUTTON_CAPS[count]);
+    std::unique_ptr<HIDP_BUTTON_CAPS[]> button_caps(
+        new HIDP_BUTTON_CAPS[count]);
     status = hidp_get_button_caps_(
         HidP_Input, button_caps.get(), &count, gamepad_info->preparsed_data);
     DCHECK_EQ(HIDP_STATUS_SUCCESS, status);
 
     for (uint32_t i = 0; i < count; ++i) {
       if (button_caps[i].Range.UsageMin <= WebGamepad::buttonsLengthCap) {
         uint32_t max_index =
             std::min(WebGamepad::buttonsLengthCap,
                      static_cast<size_t>(button_caps[i].Range.UsageMax));
         gamepad_info->buttons_length = std::max(
             gamepad_info->buttons_length, max_index);
       }
     }
   }
 
   // Query axis information.
   count = caps.NumberInputValueCaps;
-  scoped_ptr<HIDP_VALUE_CAPS[]> axes_caps(new HIDP_VALUE_CAPS[count]);
+  std::unique_ptr<HIDP_VALUE_CAPS[]> axes_caps(new HIDP_VALUE_CAPS[count]);
   status = hidp_get_value_caps_(HidP_Input, axes_caps.get(), &count,
       gamepad_info->preparsed_data);
 
   bool mapped_all_axes = true;
 
   for (UINT i = 0; i < count; i++) {
     uint32_t axis_index = axes_caps[i].Range.UsageMin - kAxisMinimumUsageNumber;
     if (axis_index < WebGamepad::axesLengthCap) {
       gamepad_info->axes[axis_index].caps = axes_caps[i];
       gamepad_info->axes[axis_index].value = 0;
@@ skipping 51 matching lines @@
     ULONG buttons_length = 0;
 
     hidp_get_usages_ex_(HidP_Input,
                         0,
                         NULL,
                         &buttons_length,
                         gamepad_info->preparsed_data,
                         reinterpret_cast<PCHAR>(input->data.hid.bRawData),
                         input->data.hid.dwSizeHid);
 
-    scoped_ptr<USAGE_AND_PAGE[]> usages(new USAGE_AND_PAGE[buttons_length]);
+    std::unique_ptr<USAGE_AND_PAGE[]> usages(
+        new USAGE_AND_PAGE[buttons_length]);
     status =
         hidp_get_usages_ex_(HidP_Input,
                             0,
                             usages.get(),
                             &buttons_length,
                             gamepad_info->preparsed_data,
                             reinterpret_cast<PCHAR>(input->data.hid.bRawData),
                             input->data.hid.dwSizeHid);
 
     if (status == HIDP_STATUS_SUCCESS) {
@@ skipping 47 matching lines @@
   UINT size = 0;
   UINT result = GetRawInputData(
       input_handle, RID_INPUT, NULL, &size, sizeof(RAWINPUTHEADER));
   if (result == static_cast<UINT>(-1)) {
     PLOG(ERROR) << "GetRawInputData() failed";
     return 0;
   }
   DCHECK_EQ(0u, result);
 
   // Retrieve the input record.
-  scoped_ptr<uint8_t[]> buffer(new uint8_t[size]);
+  std::unique_ptr<uint8_t[]> buffer(new uint8_t[size]);
   RAWINPUT* input = reinterpret_cast<RAWINPUT*>(buffer.get());
   result = GetRawInputData(
       input_handle, RID_INPUT, buffer.get(), &size, sizeof(RAWINPUTHEADER));
   if (result == static_cast<UINT>(-1)) {
     PLOG(ERROR) << "GetRawInputData() failed";
     return 0;
   }
   DCHECK_EQ(size, result);
 
   // Notify the observer about events generated locally.
@@ skipping 57 matching lines @@
     return false;
   hidd_get_product_string_ = reinterpret_cast<HidDGetStringFunc>(
       hid_dll_.GetFunctionPointer("HidD_GetProductString"));
   if (!hidd_get_product_string_)
     return false;
 
   return true;
 }
 
 }  // namespace content