Nuke WebPassOwnPtr<T> and replace it with std::unique_ptr<T>.

content/renderer/usb/web_usb_device_impl.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 "content/renderer/usb/web_usb_device_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 110 matching lines @@
       web_status = blink::WebUSBTransferInfo::Status::Babble;
       break;
     default:
       RejectWithTransferError(std::move(scoped_callbacks));
       return;
   }
   scoped_ptr<blink::WebUSBTransferInfo> info(new blink::WebUSBTransferInfo());
   info->status.assign(
       std::vector<blink::WebUSBTransferInfo::Status>(1, web_status));
   info->data.assign(data);
-  scoped_callbacks->onSuccess(adoptWebPtr(info.release()));
+  scoped_callbacks->onSuccess(std::move(info));
 }
 
 void OnTransferOut(
     ScopedWebCallbacks<blink::WebUSBDeviceTransferCallbacks> callbacks,
     size_t bytes_written,
     device::usb::TransferStatus status) {
   auto scoped_callbacks = callbacks.PassCallbacks();
   blink::WebUSBTransferInfo::Status web_status;
   switch (status) {
     case device::usb::TransferStatus::COMPLETED:
       web_status = blink::WebUSBTransferInfo::Status::Ok;
       break;
     case device::usb::TransferStatus::STALLED:
       web_status = blink::WebUSBTransferInfo::Status::Stall;
       break;
     default:
       RejectWithTransferError(std::move(scoped_callbacks));
       return;
   }
   // TODO(rockot): Device::ControlTransferOut should expose the number of bytes
   // actually transferred so we can send it from here.
   scoped_ptr<blink::WebUSBTransferInfo> info(new blink::WebUSBTransferInfo());
   info->status.assign(
       std::vector<blink::WebUSBTransferInfo::Status>(1, web_status));
   info->bytesTransferred.assign(std::vector<uint32_t>(1, bytes_written));
-  scoped_callbacks->onSuccess(adoptWebPtr(info.release()));
+  scoped_callbacks->onSuccess(std::move(info));
 }
 
 void OnIsochronousTransferIn(
     ScopedWebCallbacks<blink::WebUSBDeviceTransferCallbacks> callbacks,
     mojo::Array<uint8_t> data,
     mojo::Array<device::usb::IsochronousPacketPtr> packets) {
   auto scoped_callbacks = callbacks.PassCallbacks();
   scoped_ptr<blink::WebUSBTransferInfo> info(new blink::WebUSBTransferInfo());
   info->data.assign(data);
   info->status =
@@ skipping 11 matching lines @@
       case device::usb::TransferStatus::BABBLE:
         info->status[i] = blink::WebUSBTransferInfo::Status::Babble;
         break;
       default:
         RejectWithTransferError(std::move(scoped_callbacks));
         return;
     }
     info->packetLength[i] = packets[i]->length;
     info->bytesTransferred[i] = packets[i]->transferred_length;
   }
-  scoped_callbacks->onSuccess(adoptWebPtr(info.release()));
+  scoped_callbacks->onSuccess(std::move(info));
 }
 
 void OnIsochronousTransferOut(
     ScopedWebCallbacks<blink::WebUSBDeviceTransferCallbacks> callbacks,
     mojo::Array<device::usb::IsochronousPacketPtr> packets) {
   auto scoped_callbacks = callbacks.PassCallbacks();
   scoped_ptr<blink::WebUSBTransferInfo> info(new blink::WebUSBTransferInfo());
   info->status =
       blink::WebVector<blink::WebUSBTransferInfo::Status>(packets.size());
   info->bytesTransferred = blink::WebVector<uint32_t>(packets.size());
   for (size_t i = 0; i < packets.size(); ++i) {
     switch (packets[i]->status) {
       case device::usb::TransferStatus::COMPLETED:
         info->status[i] = blink::WebUSBTransferInfo::Status::Ok;
         break;
       case device::usb::TransferStatus::STALLED:
         info->status[i] = blink::WebUSBTransferInfo::Status::Stall;
         break;
       default:
         RejectWithTransferError(std::move(scoped_callbacks));
         return;
     }
     info->bytesTransferred[i] = packets[i]->transferred_length;
   }
-  scoped_callbacks->onSuccess(adoptWebPtr(info.release()));
+  scoped_callbacks->onSuccess(std::move(info));
 }
 
 }  // namespace
 
 WebUSBDeviceImpl::WebUSBDeviceImpl(device::usb::DevicePtr device,
                                    const blink::WebUSBDeviceInfo& device_info)
     : device_(std::move(device)),
       device_info_(device_info),
       weak_factory_(this) {
   if (device_)
@@ skipping 183 matching lines @@
 
 void WebUSBDeviceImpl::reset(blink::WebUSBDeviceResetCallbacks* callbacks) {
   auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
   if (device_)
     device_->Reset(base::Bind(&HandlePassFailDeviceOperation,
                               base::Passed(&scoped_callbacks),
                               kDeviceResetFailed));
 }
 
 }  // namespace content