Change the USB extension API to use ArrayBuffers.

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 76 matching lines @@
 template<class T>
 static bool GetTransferSize(const T& input, size_t* output) {
   if (input.direction == kDirectionIn) {
     const int* length = input.length.get();
     if (length) {
       *output = *length;
       return true;
     }
   } else if (input.direction == kDirectionOut) {
     if (input.data.get()) {
-      *output = input.data->size();
+      *output = input.data->GetSize();
       return true;
     }
   }
   return false;
 }
 
 template<class T>
 static scoped_refptr<net::IOBuffer> CreateBufferForTransfer(const T& input) {
   size_t size = 0;
   if (!GetTransferSize(input, &size)) {
     return NULL;
   }
 
   scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(size);
   if (!input.data.get()) {
     return buffer;
   }
 
-  const vector<int>& input_buffer = *input.data.get();
-  for (size_t i = 0; i < size; ++i) {
-    buffer->data()[i] = input_buffer[i];
-  }
+  memcpy(buffer->data(), input.data->GetBuffer(), size);
 
   return buffer;
 }
 
 }  // namespace
 
 namespace extensions {
 
 UsbDeviceResource::UsbDeviceResource(APIResourceEventNotifier* notifier,
                                      UsbDevice* device)
@@ skipping 72 matching lines @@
   device_->IsochronousTransfer(direction, generic_transfer.endpoint, buffer,
       size, transfer.packets, transfer.packet_length, 0, base::Bind(
           &UsbDeviceResource::TransferComplete, base::Unretained(this), buffer,
           size));
 }
 
 void UsbDeviceResource::TransferComplete(net::IOBuffer* buffer,
                                          const size_t length,
                                          int success) {
   if (buffer) {
-    base::ListValue *const response_buffer = new base::ListValue();
-    for (size_t i = 0; i < length; ++i) {
-      const uint8_t value = buffer->data()[i] & 0xFF;
-      response_buffer->Append(base::Value::CreateIntegerValue(value));
-    }
+    base::BinaryValue* const response_buffer =
+        base::BinaryValue::CreateWithCopiedBuffer(buffer->data(), length);
     event_notifier()->OnTransferComplete(success, response_buffer);
   }
 }
 
 }  // namespace extensions