Add support for isochronous transfers in WebUSB.

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"
 #include "base/strings/utf_string_conversions.h"
+#include "content/child/mojo/type_converters.h"
 #include "content/child/scoped_web_callbacks.h"
 #include "content/renderer/usb/type_converters.h"
 #include "device/devices_app/public/cpp/constants.h"
 #include "mojo/shell/public/cpp/connect.h"
 #include "mojo/shell/public/interfaces/shell.mojom.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/platform/modules/webusb/WebUSBDeviceInfo.h"
 #include "third_party/WebKit/public/platform/modules/webusb/WebUSBTransferInfo.h"
 
 namespace content {
@@ skipping 84 matching lines @@
   if (success) {
     scoped_callbacks->onSuccess();
   } else {
     RejectWithError(blink::WebUSBError(blink::WebUSBError::Error::Network,
                                        base::ASCIIToUTF16(failure_message)),
                     std::move(scoped_callbacks));
   }
 }
 
 void OnTransferIn(
-    ScopedWebCallbacks<blink::WebUSBDeviceControlTransferCallbacks> callbacks,
+    ScopedWebCallbacks<blink::WebUSBDeviceTransferCallbacks> callbacks,
     device::usb::TransferStatus status,
     mojo::Array<uint8_t> data) {
   auto scoped_callbacks = callbacks.PassCallbacks();
-  if (status != device::usb::TransferStatus::COMPLETED) {
-    RejectWithTransferError(std::move(scoped_callbacks));
-    return;
+  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;
+    case device::usb::TransferStatus::BABBLE:
+      web_status = blink::WebUSBTransferInfo::Status::Babble;
+      break;
+    default:
+      RejectWithTransferError(std::move(scoped_callbacks));
+      return;
   }
   scoped_ptr<blink::WebUSBTransferInfo> info(new blink::WebUSBTransferInfo());
-  info->status = blink::WebUSBTransferInfo::Status::Ok;
+  info->status.assign(
+      std::vector<blink::WebUSBTransferInfo::Status>(1, web_status));
   info->data.assign(data);
   scoped_callbacks->onSuccess(adoptWebPtr(info.release()));
 }
 
 void OnTransferOut(
-    ScopedWebCallbacks<blink::WebUSBDeviceControlTransferCallbacks> callbacks,
+    ScopedWebCallbacks<blink::WebUSBDeviceTransferCallbacks> callbacks,
     size_t bytes_written,
     device::usb::TransferStatus status) {
   auto scoped_callbacks = callbacks.PassCallbacks();
-  scoped_ptr<blink::WebUSBTransferInfo> info(new blink::WebUSBTransferInfo());
+  blink::WebUSBTransferInfo::Status web_status;
   switch (status) {
     case device::usb::TransferStatus::COMPLETED:
-      info->status = blink::WebUSBTransferInfo::Status::Ok;
+      web_status = blink::WebUSBTransferInfo::Status::Ok;
       break;
     case device::usb::TransferStatus::STALLED:
-      info->status = blink::WebUSBTransferInfo::Status::Stall;
-      break;
-    case device::usb::TransferStatus::BABBLE:
-      info->status = blink::WebUSBTransferInfo::Status::Babble;
+      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.
-  info->bytesWritten = bytes_written;
+  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()));
 }
 
+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);
+  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;
+      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()));
+}
+
+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());
+  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()));
+}
+
 }  // namespace
 
 WebUSBDeviceImpl::WebUSBDeviceImpl(device::usb::DevicePtr device,
                                    const blink::WebUSBDeviceInfo& device_info)
     : device_(std::move(device)),
       device_info_(device_info),
       weak_factory_(this) {}
 
 WebUSBDeviceImpl::~WebUSBDeviceImpl() {}
 
@@ skipping 67 matching lines @@
       endpoint_number,
       base::Bind(&HandlePassFailDeviceOperation,
                  base::Passed(&scoped_callbacks), kClearHaltFailed));
 }
 
 void WebUSBDeviceImpl::controlTransfer(
     const blink::WebUSBDevice::ControlTransferParameters& parameters,
     uint8_t* data,
     size_t data_size,
     unsigned int timeout,
-    blink::WebUSBDeviceControlTransferCallbacks* callbacks) {
+    blink::WebUSBDeviceTransferCallbacks* callbacks) {
   auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
   device::usb::ControlTransferParamsPtr params =
       device::usb::ControlTransferParams::From(parameters);
   switch (parameters.direction) {
     case WebUSBDevice::TransferDirection::In:
       device_->ControlTransferIn(
           std::move(params), data_size, timeout,
           base::Bind(&OnTransferIn, base::Passed(&scoped_callbacks)));
       break;
     case WebUSBDevice::TransferDirection::Out: {
@@ skipping 12 matching lines @@
       NOTREACHED();
   }
 }
 
 void WebUSBDeviceImpl::transfer(
     blink::WebUSBDevice::TransferDirection direction,
     uint8_t endpoint_number,
     uint8_t* data,
     size_t data_size,
     unsigned int timeout,
-    blink::WebUSBDeviceBulkTransferCallbacks* callbacks) {
+    blink::WebUSBDeviceTransferCallbacks* callbacks) {
   auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
   switch (direction) {
     case WebUSBDevice::TransferDirection::In:
       device_->GenericTransferIn(
           endpoint_number, data_size, timeout,
           base::Bind(&OnTransferIn, base::Passed(&scoped_callbacks)));
       break;
     case WebUSBDevice::TransferDirection::Out: {
       std::vector<uint8_t> bytes;
       if (data)
         bytes.assign(data, data + data_size);
       mojo::Array<uint8_t> mojo_bytes;
       mojo_bytes.Swap(&bytes);
       device_->GenericTransferOut(
           endpoint_number, std::move(mojo_bytes), timeout,
           base::Bind(&OnTransferOut, base::Passed(&scoped_callbacks),
                      data_size));
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
+void WebUSBDeviceImpl::isochronousTransfer(
+    blink::WebUSBDevice::TransferDirection direction,
+    uint8_t endpoint_number,
+    uint8_t* data,
+    size_t data_size,
+    blink::WebVector<uint32_t> packet_lengths,
+    unsigned int timeout,
+    blink::WebUSBDeviceTransferCallbacks* callbacks) {
+  auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
+  switch (direction) {
+    case WebUSBDevice::TransferDirection::In:
+      device_->IsochronousTransferIn(
+          endpoint_number, mojo::Array<uint32_t>::From(packet_lengths), timeout,
+          base::Bind(&OnIsochronousTransferIn,
+                     base::Passed(&scoped_callbacks)));
+      break;
+    case WebUSBDevice::TransferDirection::Out: {
+      std::vector<uint8_t> bytes;
+      if (data)
+        bytes.assign(data, data + data_size);
+      mojo::Array<uint8_t> mojo_bytes;
+      mojo_bytes.Swap(&bytes);
+      device_->IsochronousTransferOut(
+          endpoint_number, std::move(mojo_bytes),
+          mojo::Array<uint32_t>::From(packet_lengths), timeout,
+          base::Bind(&OnIsochronousTransferOut,
+                     base::Passed(&scoped_callbacks)));
+      break;
+    }
+    default:
+      NOTREACHED();
+  }
+}
+
 void WebUSBDeviceImpl::reset(blink::WebUSBDeviceResetCallbacks* callbacks) {
   auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
   device_->Reset(base::Bind(&HandlePassFailDeviceOperation,
                             base::Passed(&scoped_callbacks),
                             kDeviceResetFailed));
 }
 
 }  // namespace content