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

extensions/browser/api/usb/usb_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/usb/usb_api.h"
 
 #include <algorithm>
 #include <memory>
 #include <numeric>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/barrier_closure.h"
-#include "base/memory/ptr_util.h"
 #include "device/core/device_client.h"
 #include "device/usb/usb_descriptors.h"
 #include "device/usb/usb_device_handle.h"
 #include "device/usb/usb_service.h"
 #include "extensions/browser/api/device_permissions_manager.h"
 #include "extensions/browser/api/device_permissions_prompt.h"
 #include "extensions/browser/api/extensions_api_client.h"
 #include "extensions/browser/api/usb/usb_device_resource.h"
 #include "extensions/browser/api/usb/usb_guid_map.h"
 #include "extensions/browser/extension_system.h"
@@ skipping 216 matching lines @@
     case device::USB_TRANSFER_OVERFLOW:
       return kErrorOverflow;
     case device::USB_TRANSFER_LENGTH_SHORT:
       return kErrorTransferLength;
     default:
       NOTREACHED();
       return "";
   }
 }
 
-std::unique_ptr<base::Value> PopulateConnectionHandle(int handle,
-                                                      int vendor_id,
-                                                      int product_id) {
+base::Value* PopulateConnectionHandle(int handle,
+                                      int vendor_id,
+                                      int product_id) {
   ConnectionHandle result;
   result.handle = handle;
   result.vendor_id = vendor_id;
   result.product_id = product_id;
-  return result.ToValue();
+  return result.ToValue().release();
 }
 
 TransferType ConvertTransferTypeToApi(const UsbTransferType& input) {
   switch (input) {
     case device::USB_TRANSFER_CONTROL:
       return usb::TRANSFER_TYPE_CONTROL;
     case device::USB_TRANSFER_INTERRUPT:
       return usb::TRANSFER_TYPE_INTERRUPT;
     case device::USB_TRANSFER_ISOCHRONOUS:
       return usb::TRANSFER_TYPE_ISOCHRONOUS;
@@ skipping 336 matching lines @@
 
 UsbGetUserSelectedDevicesFunction::~UsbGetUserSelectedDevicesFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbGetUserSelectedDevicesFunction::Run() {
   std::unique_ptr<extensions::api::usb::GetUserSelectedDevices::Params>
       parameters = GetUserSelectedDevices::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   if (!user_gesture()) {
-    return RespondNow(OneArgument(base::MakeUnique<base::ListValue>()));
+    return RespondNow(OneArgument(new base::ListValue()));
   }
 
   bool multiple = false;
   if (parameters->options.multiple) {
     multiple = *parameters->options.multiple;
   }
 
   std::vector<UsbDeviceFilter> filters;
   if (parameters->options.filters) {
     filters.resize(parameters->options.filters->size());
@@ skipping 74 matching lines @@
 UsbRequestAccessFunction::UsbRequestAccessFunction() {
 }
 
 UsbRequestAccessFunction::~UsbRequestAccessFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbRequestAccessFunction::Run() {
   std::unique_ptr<extensions::api::usb::RequestAccess::Params> parameters =
       RequestAccess::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
-  return RespondNow(
-      OneArgument(base::MakeUnique<base::FundamentalValue>(true)));
+  return RespondNow(OneArgument(new base::FundamentalValue(true)));
 }
 
 UsbOpenDeviceFunction::UsbOpenDeviceFunction() {
 }
 
 UsbOpenDeviceFunction::~UsbOpenDeviceFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbOpenDeviceFunction::Run() {
   std::unique_ptr<extensions::api::usb::OpenDevice::Params> parameters =
@@ skipping 523 matching lines @@
     return RespondNow(Error(kErrorNoConnection));
   }
 
   device_handle->ResetDevice(
       base::Bind(&UsbResetDeviceFunction::OnComplete, this));
   return RespondLater();
 }
 
 void UsbResetDeviceFunction::OnComplete(bool success) {
   if (success) {
-    Respond(OneArgument(base::MakeUnique<base::FundamentalValue>(true)));
+    Respond(OneArgument(new base::FundamentalValue(true)));
   } else {
     scoped_refptr<UsbDeviceHandle> device_handle =
         GetDeviceHandle(parameters_->handle);
     if (device_handle.get()) {
       device_handle->Close();
     }
     ReleaseDeviceHandle(parameters_->handle);
 
     std::unique_ptr<base::ListValue> error_args(new base::ListValue());
     error_args->AppendBoolean(false);
     // Using ErrorWithArguments is discouraged but required to maintain
     // compatibility with existing applications.
     Respond(ErrorWithArguments(std::move(error_args), kErrorResetDevice));
   }
 }
 
 }  // namespace extensions