Changing USB API buffer ownership.

chrome/browser/extensions/api/usb/usb_device_resource.cc

 // Copyright (c) 2012 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 "chrome/browser/extensions/api/usb/usb_device_resource.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 169 matching lines @@
       !ConvertRequestType(transfer.request_type, &request_type) ||
       !ConvertRecipient(transfer.recipient, &recipient) ||
       !GetTransferSize(transfer, &size) || !buffer) {
     LOG(INFO) << "Malformed transfer parameters.";
     return;
   }
 
   device_->ControlTransfer(direction, request_type, recipient, transfer.request,
                            transfer.value, transfer.index, buffer, size, 0,
                            base::Bind(&UsbDeviceResource::TransferComplete,
-                                      base::Unretained(this), buffer, size));
+                                      base::Unretained(this)));
 }
 
 void UsbDeviceResource::InterruptTransfer(const GenericTransferInfo& transfer) {
   size_t size;
   UsbDevice::TransferDirection direction;
   scoped_refptr<net::IOBuffer> buffer = CreateBufferForTransfer(transfer);
 
   if (!ConvertDirection(transfer.direction, &direction) ||
       !GetTransferSize(transfer, &size) || !buffer) {
     LOG(INFO) << "Malformed transfer parameters.";
     return;
   }
 
   device_->InterruptTransfer(direction, transfer.endpoint, buffer, size, 0,
                              base::Bind(&UsbDeviceResource::TransferComplete,
-                                        base::Unretained(this), buffer, size));
+                                        base::Unretained(this)));
 }
 
 void UsbDeviceResource::BulkTransfer(const GenericTransferInfo& transfer) {
   size_t size;
   UsbDevice::TransferDirection direction;
   scoped_refptr<net::IOBuffer> buffer = CreateBufferForTransfer(transfer);
 
   if (!ConvertDirection(transfer.direction, &direction) ||
       !GetTransferSize(transfer, &size) || !buffer) {
     LOG(INFO) << "Malformed transfer parameters.";
     return;
   }
 
   device_->BulkTransfer(direction, transfer.endpoint, buffer, size, 0,
                         base::Bind(&UsbDeviceResource::TransferComplete,
-                                   base::Unretained(this), buffer, size));
+                                   base::Unretained(this)));
 }
 
 void UsbDeviceResource::IsochronousTransfer(
     const IsochronousTransferInfo& transfer) {
   const GenericTransferInfo& generic_transfer = transfer.transfer_info;
 
   size_t size;
   UsbDevice::TransferDirection direction;
   scoped_refptr<net::IOBuffer> buffer = CreateBufferForTransfer(
       generic_transfer);
 
   if (!ConvertDirection(generic_transfer.direction, &direction) ||
       !GetTransferSize(generic_transfer, &size) || !buffer) {
     LOG(INFO) << "Malformed transfer parameters.";
     return;
   }
 
   device_->IsochronousTransfer(direction, generic_transfer.endpoint, buffer,
       size, transfer.packets, transfer.packet_length, 0, base::Bind(
-          &UsbDeviceResource::TransferComplete, base::Unretained(this), buffer,
-          size));
+          &UsbDeviceResource::TransferComplete, base::Unretained(this)));
 }
 
-void UsbDeviceResource::TransferComplete(net::IOBuffer* buffer,
-                                         const size_t length,
-                                         UsbTransferStatus status) {
-  if (buffer) {
-    base::BinaryValue* const response_buffer =
-        base::BinaryValue::CreateWithCopiedBuffer(buffer->data(), length);
-    event_notifier()->OnTransferComplete(status,
-        ConvertTransferStatusToErrorString(status), response_buffer);
-  }
+void UsbDeviceResource::TransferComplete(UsbTransferStatus status,
+                                         scoped_refptr<net::IOBuffer> buffer,
+                                         size_t length) {
+  base::BinaryValue* response_buffer =
+      base::BinaryValue::CreateWithCopiedBuffer(buffer->data(), length);
+  event_notifier()->OnTransferComplete(status,
+      ConvertTransferStatusToErrorString(status), response_buffer);
 }
 
 }  // namespace extensions