Update device/usb and its Mojo interface for variable size ISO packets.

device/usb/usb_device_handle.h

 // 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.
 
 #ifndef DEVICE_USB_USB_DEVICE_HANDLE_H_
 #define DEVICE_USB_USB_DEVICE_HANDLE_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 22 matching lines @@
   USB_TRANSFER_CANCELLED,
   USB_TRANSFER_STALLED,
   USB_TRANSFER_DISCONNECT,
   USB_TRANSFER_OVERFLOW,
   USB_TRANSFER_LENGTH_SHORT,
 };
 
 // UsbDeviceHandle class provides basic I/O related functionalities.
 class UsbDeviceHandle : public base::RefCountedThreadSafe<UsbDeviceHandle> {
  public:
+  struct IsochronousPacket {
+    uint32_t length;
+    uint32_t transferred_length;
+    UsbTransferStatus status;
+  };
+
   using ResultCallback = base::Callback<void(bool)>;
   using TransferCallback = base::Callback<
       void(UsbTransferStatus, scoped_refptr<net::IOBuffer>, size_t)>;
+  using IsochronousTransferCallback =
+      base::Callback<void(scoped_refptr<net::IOBuffer>,
+                          const std::vector<IsochronousPacket>& packets)>;
 
   enum TransferRequestType { STANDARD, CLASS, VENDOR, RESERVED };
   enum TransferRecipient { DEVICE, INTERFACE, ENDPOINT, OTHER };
 
   virtual scoped_refptr<UsbDevice> GetDevice() const = 0;
 
   // Notifies UsbDevice to drop the reference of this object; cancels all the
   // flying transfers.
   // It is possible that the object has no other reference after this call. So
   // if it is called using a raw pointer, it could be invalidated.
@@ skipping 18 matching lines @@
                                TransferRequestType request_type,
                                TransferRecipient recipient,
                                uint8_t request,
                                uint16_t value,
                                uint16_t index,
                                scoped_refptr<net::IOBuffer> buffer,
                                size_t length,
                                unsigned int timeout,
                                const TransferCallback& callback) = 0;
 
-  virtual void IsochronousTransfer(UsbEndpointDirection direction,
-                                   uint8_t endpoint,
-                                   scoped_refptr<net::IOBuffer> buffer,
-                                   size_t length,
-                                   unsigned int packets,
-                                   unsigned int packet_length,
-                                   unsigned int timeout,
-                                   const TransferCallback& callback) = 0;
+  virtual void IsochronousTransferIn(
+      uint8_t endpoint_number,
+      const std::vector<uint32_t>& packet_lengths,
+      unsigned int timeout,
+      const IsochronousTransferCallback& callback) = 0;
+
+  virtual void IsochronousTransferOut(
+      uint8_t endpoint_number,
+      scoped_refptr<net::IOBuffer> buffer,
+      const std::vector<uint32_t>& packet_lengths,
+      unsigned int timeout,
+      const IsochronousTransferCallback& callback) = 0;
 
   virtual void GenericTransfer(UsbEndpointDirection direction,
-                               uint8_t endpoint,
+                               uint8_t endpoint_number,
                                scoped_refptr<net::IOBuffer> buffer,
                                size_t length,
                                unsigned int timeout,
                                const TransferCallback& callback) = 0;
 
   // Gets the interface containing |endpoint_address|. Returns false if no
   // claimed interface contains that endpoint.
   virtual bool FindInterfaceByEndpoint(uint8_t endpoint_address,
                                        uint8_t* interface_number) = 0;
 
  protected:
   friend class base::RefCountedThreadSafe<UsbDeviceHandle>;
 
   UsbDeviceHandle();
 
   virtual ~UsbDeviceHandle();
 
+ private:
   DISALLOW_COPY_AND_ASSIGN(UsbDeviceHandle);
 };
 
 }  // namespace device
 
 #endif  // DEVICE_USB_USB_DEVICE_HANDLE_H_