ExtensionFunction: don't pass ownership of base::Value by raw pointer.

extensions/browser/api/hid/hid_api.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_api.h"
 
 #include <stdint.h>
 
 #include <string>
+#include <utility>
 #include <vector>
 
+#include "base/memory/ptr_util.h"
 #include "device/core/device_client.h"
 #include "device/hid/hid_connection.h"
 #include "device/hid/hid_device_filter.h"
 #include "device/hid/hid_device_info.h"
 #include "device/hid/hid_service.h"
 #include "extensions/browser/api/api_resource_manager.h"
 #include "extensions/browser/api/device_permissions_prompt.h"
 #include "extensions/browser/api/extensions_api_client.h"
 #include "extensions/common/api/hid.h"
 #include "net/base/io_buffer.h"
@@ skipping 27 matching lines @@
 using device::HidService;
 
 namespace {
 
 const char kErrorPermissionDenied[] = "Permission to access device was denied.";
 const char kErrorInvalidDeviceId[] = "Invalid HID device ID.";
 const char kErrorFailedToOpenDevice[] = "Failed to open HID device.";
 const char kErrorConnectionNotFound[] = "Connection not established.";
 const char kErrorTransfer[] = "Transfer failed.";
 
-base::Value* PopulateHidConnection(int connection_id,
-                                   scoped_refptr<HidConnection> connection) {
+std::unique_ptr<base::Value> PopulateHidConnection(
+    int connection_id,
+    scoped_refptr<HidConnection> connection) {
   hid::HidConnectInfo connection_value;
   connection_value.connection_id = connection_id;
-  return connection_value.ToValue().release();
+  return connection_value.ToValue();
 }
 
 void ConvertHidDeviceFilter(const hid::DeviceFilter& input,
                             HidDeviceFilter* output) {
   if (input.vendor_id) {
     output->SetVendorId(*input.vendor_id);
   }
   if (input.product_id) {
     output->SetProductId(*input.product_id);
   }
@@ skipping 38 matching lines @@
   }
 
   device_manager->GetApiDevices(
       extension(), filters,
       base::Bind(&HidGetDevicesFunction::OnEnumerationComplete, this));
   return RespondLater();
 }
 
 void HidGetDevicesFunction::OnEnumerationComplete(
     std::unique_ptr<base::ListValue> devices) {
-  Respond(OneArgument(devices.release()));
+  Respond(OneArgument(std::move(devices)));
 }
 
 HidGetUserSelectedDevicesFunction::HidGetUserSelectedDevicesFunction() {
 }
 
 HidGetUserSelectedDevicesFunction::~HidGetUserSelectedDevicesFunction() {
 }
 
 ExtensionFunction::ResponseAction HidGetUserSelectedDevicesFunction::Run() {
   std::unique_ptr<api::hid::GetUserSelectedDevices::Params> parameters =
       hid::GetUserSelectedDevices::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters);
 
   content::WebContents* web_contents = GetSenderWebContents();
   if (!web_contents || !user_gesture()) {
-    return RespondNow(OneArgument(new base::ListValue()));
+    return RespondNow(OneArgument(base::MakeUnique<base::ListValue>()));
   }
 
   bool multiple = false;
   std::vector<HidDeviceFilter> filters;
   if (parameters->options) {
     multiple = parameters->options->multiple && *parameters->options->multiple;
     if (parameters->options->filters) {
       const auto& api_filters = *parameters->options->filters;
       filters.resize(api_filters.size());
       for (size_t i = 0; i < api_filters.size(); ++i) {
@@ skipping 131 matching lines @@
   connection->Read(base::Bind(&HidReceiveFunction::OnFinished, this));
 }
 
 void HidReceiveFunction::OnFinished(bool success,
                                     scoped_refptr<net::IOBuffer> buffer,
                                     size_t size) {
   if (success) {
     DCHECK_GE(size, 1u);
     int report_id = reinterpret_cast<uint8_t*>(buffer->data())[0];
 
-    Respond(TwoArguments(new base::FundamentalValue(report_id),
-                         base::BinaryValue::CreateWithCopiedBuffer(
-                             buffer->data() + 1, size - 1)));
+    Respond(
+        TwoArguments(base::MakeUnique<base::FundamentalValue>(report_id),
+                     base::WrapUnique(base::BinaryValue::CreateWithCopiedBuffer(
+                         buffer->data() + 1, size - 1))));
   } else {
     Respond(Error(kErrorTransfer));
   }
 }
 
 HidSendFunction::HidSendFunction() {}
 
 HidSendFunction::~HidSendFunction() {}
 
 bool HidSendFunction::ValidateParameters() {
@@ skipping 36 matching lines @@
   connection->GetFeatureReport(
       static_cast<uint8_t>(parameters_->report_id),
       base::Bind(&HidReceiveFeatureReportFunction::OnFinished, this));
 }
 
 void HidReceiveFeatureReportFunction::OnFinished(
     bool success,
     scoped_refptr<net::IOBuffer> buffer,
     size_t size) {
   if (success) {
-    Respond(OneArgument(
-        base::BinaryValue::CreateWithCopiedBuffer(buffer->data(), size)));
+    Respond(OneArgument(base::WrapUnique(
+        base::BinaryValue::CreateWithCopiedBuffer(buffer->data(), size))));
   } else {
     Respond(Error(kErrorTransfer));
   }
 }
 
 HidSendFeatureReportFunction::HidSendFeatureReportFunction() {}
 
 HidSendFeatureReportFunction::~HidSendFeatureReportFunction() {}
 
 bool HidSendFeatureReportFunction::ValidateParameters() {
@@ skipping 16 matching lines @@
 
 void HidSendFeatureReportFunction::OnFinished(bool success) {
   if (success) {
     Respond(NoArguments());
   } else {
     Respond(Error(kErrorTransfer));
   }
 }
 
 }  // namespace extensions