Consume Mojo services directly in Blink's WebUSB implementation.

third_party/WebKit/Source/modules/webusb/USBDevice.h

Index: third_party/WebKit/Source/modules/webusb/USBDevice.h
diff --git a/third_party/WebKit/Source/modules/webusb/USBDevice.h b/third_party/WebKit/Source/modules/webusb/USBDevice.h
index 9b5154b85c006e597c20bb8a9aadf5c400ccc3e0..17bff6b005cff03fc2f10fe05eb6e83f41f6a472 100644
--- a/third_party/WebKit/Source/modules/webusb/USBDevice.h
+++ b/third_party/WebKit/Source/modules/webusb/USBDevice.h
@@ -9,9 +9,8 @@
 #include "bindings/core/v8/ScriptWrappable.h"
 #include "bindings/modules/v8/UnionTypesModules.h"
 #include "core/dom/ContextLifecycleObserver.h"
+#include "device/usb/public/interfaces/device.mojom-wtf.h"
 #include "platform/heap/Handle.h"
-#include "public/platform/modules/webusb/WebUSBDevice.h"
-#include "public/platform/modules/webusb/WebUSBDeviceInfo.h"
 #include "wtf/BitVector.h"
 #include "wtf/Vector.h"
 
@@ -29,42 +28,34 @@ class USBDevice
     USING_GARBAGE_COLLECTED_MIXIN(USBDevice);
     DEFINE_WRAPPERTYPEINFO();
 public:
-    using WebType = OwnPtr<WebUSBDevice>;
-
-    static USBDevice* create(PassOwnPtr<WebUSBDevice> device, ExecutionContext* context)
+    static USBDevice* create(device::usb::wtf::DeviceInfoPtr deviceInfo, device::usb::wtf::DevicePtr device, ExecutionContext* context)
     {
-        return new USBDevice(device, context);
+        return new USBDevice(std::move(deviceInfo), std::move(device), context);
     }
 
-    static USBDevice* take(ScriptPromiseResolver*, PassOwnPtr<WebUSBDevice>);
-
-    explicit USBDevice(PassOwnPtr<WebUSBDevice>, ExecutionContext*);
-    virtual ~USBDevice() { }
+    explicit USBDevice(device::usb::wtf::DeviceInfoPtr, device::usb::wtf::DevicePtr, ExecutionContext*);
+    virtual ~USBDevice();
 
-    const WebUSBDeviceInfo& info() const { return m_device->info(); }
-    void onDeviceOpenedOrClosed(bool);
-    void onConfigurationSelected(bool success, size_t configurationIndex);
-    void onInterfaceClaimedOrUnclaimed(bool claimed, size_t interfaceIndex);
-    void onAlternateInterfaceSelected(bool success, size_t interfaceIndex, size_t alternateIndex);
+    const device::usb::wtf::DeviceInfo& info() const { return *m_deviceInfo; }
     bool isInterfaceClaimed(size_t configurationIndex, size_t interfaceIndex) const;
     size_t selectedAlternateInterface(size_t interfaceIndex) const;
 
-    // IDL exposed interface:
+    // USBDevice.idl
     String guid() const { return info().guid; }
-    uint8_t usbVersionMajor() { return info().usbVersionMajor; }
-    uint8_t usbVersionMinor() { return info().usbVersionMinor; }
-    uint8_t usbVersionSubminor() { return info().usbVersionSubminor; }
-    uint8_t deviceClass() { return info().deviceClass; }
-    uint8_t deviceSubclass() const { return info().deviceSubclass; }
-    uint8_t deviceProtocol() const { return info().deviceProtocol; }
-    uint16_t vendorId() const { return info().vendorID; }
-    uint16_t productId() const { return info().productID; }
-    uint8_t deviceVersionMajor() const { return info().deviceVersionMajor; }
-    uint8_t deviceVersionMinor() const { return info().deviceVersionMinor; }
-    uint8_t deviceVersionSubminor() const { return info().deviceVersionSubminor; }
-    String manufacturerName() const { return info().manufacturerName; }
-    String productName() const { return info().productName; }
-    String serialNumber() const { return info().serialNumber; }
+    uint8_t usbVersionMajor() const { return info().usb_version_major; }
+    uint8_t usbVersionMinor() const { return info().usb_version_minor; }
+    uint8_t usbVersionSubminor() const { return info().usb_version_subminor; }
+    uint8_t deviceClass() const { return info().class_code; }
+    uint8_t deviceSubclass() const { return info().subclass_code; }
+    uint8_t deviceProtocol() const { return info().protocol_code; }
+    uint16_t vendorId() const { return info().vendor_id; }
+    uint16_t productId() const { return info().product_id; }
+    uint8_t deviceVersionMajor() const { return info().device_version_major; }
+    uint8_t deviceVersionMinor() const { return info().device_version_minor; }
+    uint8_t deviceVersionSubminor() const { return info().device_version_subminor; }
+    String manufacturerName() const { return info().manufacturer_name; }
+    String productName() const { return info().product_name; }
+    String serialNumber() const { return info().serial_number; }
     USBConfiguration* configuration() const;
     HeapVector<Member<USBConfiguration>> configurations() const;
     bool opened() const { return m_opened; }
@@ -99,10 +90,30 @@ private:
     bool ensureInterfaceClaimed(uint8_t interfaceNumber, ScriptPromiseResolver*) const;
     bool ensureEndpointAvailable(bool inTransfer, uint8_t endpointNumber, ScriptPromiseResolver*) const;
     bool anyInterfaceChangeInProgress() const;
-    bool convertControlTransferParameters(WebUSBDevice::TransferDirection, const USBControlTransferParameters&, WebUSBDevice::ControlTransferParameters*, ScriptPromiseResolver*) const;
+    device::usb::wtf::ControlTransferParamsPtr convertControlTransferParameters(const USBControlTransferParameters&, ScriptPromiseResolver*) const;
     void setEndpointsForInterface(size_t interfaceIndex, bool set);
 
-    OwnPtr<WebUSBDevice> m_device;
+    void asyncOpen(ScriptPromiseResolver*, device::usb::wtf::OpenDeviceError);
+    void asyncClose(ScriptPromiseResolver*);
+    void onDeviceOpenedOrClosed(bool);
+    void asyncSelectConfiguration(size_t configurationIndex, ScriptPromiseResolver*, bool success);
+    void onConfigurationSelected(bool success, size_t configurationIndex);
+    void asyncClaimInterface(size_t interfaceIndex, ScriptPromiseResolver*, bool success);
+    void asyncReleaseInterface(size_t interfaceIndex, ScriptPromiseResolver*, bool success);
+    void onInterfaceClaimedOrUnclaimed(bool claimed, size_t interfaceIndex);
+    void asyncSelectAlternateInterface(size_t interfaceIndex, size_t alternateIndex, ScriptPromiseResolver*, bool success);
+    void asyncControlTransferIn(ScriptPromiseResolver*, device::usb::wtf::TransferStatus, mojo::WTFArray<uint8_t>);
+    void asyncControlTransferOut(unsigned, ScriptPromiseResolver*, device::usb::wtf::TransferStatus);
+    void asyncClearHalt(ScriptPromiseResolver*, bool success);
+    void asyncTransferIn(ScriptPromiseResolver*, device::usb::wtf::TransferStatus, mojo::WTFArray<uint8_t>);
+    void asyncTransferOut(unsigned, ScriptPromiseResolver*, device::usb::wtf::TransferStatus);
+    void asyncIsochronousTransferIn(ScriptPromiseResolver*, mojo::WTFArray<uint8_t>, mojo::WTFArray<device::usb::wtf::IsochronousPacketPtr>);
+    void asyncIsochronousTransferOut(ScriptPromiseResolver*, mojo::WTFArray<device::usb::wtf::IsochronousPacketPtr>);
+    void asyncReset(ScriptPromiseResolver*, bool success);
+
+    device::usb::wtf::DeviceInfoPtr m_deviceInfo;
+    device::usb::wtf::DevicePtr m_device;
+    HeapHashSet<Member<ScriptPromiseResolver>> m_deviceRequests;
     bool m_opened;
     bool m_deviceStateChangeInProgress;
     int m_configurationIndex;