| // Copyright 2015 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_WEBUSB_USB_DEVICE_H_ |
| #define THIRD_PARTY_BLINK_RENDERER_MODULES_WEBUSB_USB_DEVICE_H_ |
| |
| #include <bitset> |
| |
| #include "base/containers/span.h" |
| #include "mojo/public/cpp/bindings/pending_remote.h" |
| #include "services/device/public/mojom/usb_device.mojom-blink.h" |
| #include "third_party/blink/renderer/bindings/core/v8/script_promise.h" |
| #include "third_party/blink/renderer/bindings/core/v8/script_promise_resolver.h" |
| #include "third_party/blink/renderer/core/execution_context/execution_context_lifecycle_observer.h" |
| #include "third_party/blink/renderer/core/typed_arrays/dom_array_piece.h" |
| #include "third_party/blink/renderer/platform/bindings/script_wrappable.h" |
| #include "third_party/blink/renderer/platform/heap/collection_support/heap_hash_set.h" |
| #include "third_party/blink/renderer/platform/heap/garbage_collected.h" |
| #include "third_party/blink/renderer/platform/mojo/heap_mojo_remote.h" |
| #include "third_party/blink/renderer/platform/wtf/vector.h" |
| |
| namespace blink { |
| |
| class ScriptState; |
| class USB; |
| class USBConfiguration; |
| class USBControlTransferParameters; |
| class USBInTransferResult; |
| class USBIsochronousInTransferResult; |
| class USBIsochronousOutTransferResult; |
| class USBOutTransferResult; |
| class V8USBDirection; |
| |
| class USBDevice : public ScriptWrappable, |
| public ExecutionContextLifecycleObserver { |
| DEFINE_WRAPPERTYPEINFO(); |
| |
| public: |
| explicit USBDevice(USB* parent, |
| device::mojom::blink::UsbDeviceInfoPtr, |
| mojo::PendingRemote<device::mojom::blink::UsbDevice>, |
| ExecutionContext*); |
| ~USBDevice() override; |
| |
| const device::mojom::blink::UsbDeviceInfo& Info() const { |
| return *device_info_; |
| } |
| bool IsInterfaceClaimed(wtf_size_t configuration_index, |
| wtf_size_t interface_index) const; |
| wtf_size_t SelectedAlternateInterfaceIndex(wtf_size_t interface_index) const; |
| |
| // USBDevice.idl |
| 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 opened_; } |
| |
| ScriptPromise<IDLUndefined> open(ScriptState*, ExceptionState&); |
| ScriptPromise<IDLUndefined> close(ScriptState*, ExceptionState&); |
| ScriptPromise<IDLUndefined> forget(ScriptState*, ExceptionState&); |
| ScriptPromise<IDLUndefined> selectConfiguration(ScriptState*, |
| uint8_t configuration_value, |
| ExceptionState&); |
| ScriptPromise<IDLUndefined> claimInterface(ScriptState*, |
| uint8_t interface_number, |
| ExceptionState&); |
| ScriptPromise<IDLUndefined> releaseInterface(ScriptState*, |
| uint8_t interface_number, |
| ExceptionState&); |
| ScriptPromise<IDLUndefined> selectAlternateInterface( |
| ScriptState*, |
| uint8_t interface_number, |
| uint8_t alternate_setting, |
| ExceptionState&); |
| ScriptPromise<USBInTransferResult> controlTransferIn( |
| ScriptState*, |
| const USBControlTransferParameters* setup, |
| uint16_t length, |
| ExceptionState&); |
| ScriptPromise<USBOutTransferResult> controlTransferOut( |
| ScriptState*, |
| const USBControlTransferParameters* setup, |
| ExceptionState&); |
| ScriptPromise<USBOutTransferResult> controlTransferOut( |
| ScriptState*, |
| const USBControlTransferParameters* setup, |
| base::span<const uint8_t> data, |
| ExceptionState&); |
| ScriptPromise<IDLUndefined> clearHalt(ScriptState*, |
| const V8USBDirection& direction, |
| uint8_t endpoint_number, |
| ExceptionState&); |
| ScriptPromise<USBInTransferResult> transferIn(ScriptState*, |
| uint8_t endpoint_number, |
| unsigned length, |
| ExceptionState&); |
| ScriptPromise<USBOutTransferResult> transferOut( |
| ScriptState*, |
| uint8_t endpoint_number, |
| base::span<const uint8_t> data, |
| ExceptionState&); |
| ScriptPromise<USBIsochronousInTransferResult> isochronousTransferIn( |
| ScriptState*, |
| uint8_t endpoint_number, |
| Vector<unsigned> packet_lengths, |
| ExceptionState&); |
| ScriptPromise<USBIsochronousOutTransferResult> isochronousTransferOut( |
| ScriptState*, |
| uint8_t endpoint_number, |
| base::span<const uint8_t> data, |
| Vector<unsigned> packet_lengths, |
| ExceptionState&); |
| ScriptPromise<IDLUndefined> reset(ScriptState*, ExceptionState&); |
| |
| // ExecutionContextLifecycleObserver interface. |
| void ContextDestroyed() override; |
| |
| void Trace(Visitor*) const override; |
| |
| private: |
| static const size_t kEndpointsBitsNumber = 16; |
| |
| wtf_size_t FindConfigurationIndex(uint8_t configuration_value) const; |
| wtf_size_t FindInterfaceIndex(uint8_t interface_number) const; |
| wtf_size_t FindAlternateIndex(wtf_size_t interface_index, |
| uint8_t alternate_setting) const; |
| void EnsureNoDeviceChangeInProgress(ExceptionState&) const; |
| void EnsureNoDeviceOrInterfaceChangeInProgress(ExceptionState&) const; |
| void EnsureDeviceConfigured(ExceptionState&) const; |
| void EnsureInterfaceClaimed(uint8_t interface_number, ExceptionState&) const; |
| void EnsureEndpointAvailable(bool in_transfer, |
| uint8_t endpoint_number, |
| ExceptionState&) const; |
| bool AnyInterfaceChangeInProgress() const; |
| device::mojom::blink::UsbControlTransferParamsPtr |
| ConvertControlTransferParameters(const USBControlTransferParameters*, |
| ExceptionState&) const; |
| void SetEndpointsForInterface(wtf_size_t interface_index, bool set); |
| |
| void AsyncOpen(ScriptPromiseResolver<IDLUndefined>*, |
| device::mojom::blink::UsbOpenDeviceResultPtr); |
| void AsyncClose(ScriptPromiseResolver<IDLUndefined>*); |
| static void AsyncForget(ScriptPromiseResolver<IDLUndefined>*); |
| void OnDeviceOpenedOrClosed(bool); |
| void AsyncSelectConfiguration(wtf_size_t configuration_index, |
| ScriptPromiseResolver<IDLUndefined>*, |
| bool success); |
| void OnConfigurationSelected(bool success, wtf_size_t configuration_index); |
| void AsyncClaimInterface( |
| wtf_size_t interface_index, |
| ScriptPromiseResolver<IDLUndefined>*, |
| device::mojom::blink::UsbClaimInterfaceResult result); |
| void AsyncReleaseInterface(wtf_size_t interface_index, |
| ScriptPromiseResolver<IDLUndefined>*, |
| bool success); |
| void OnInterfaceClaimedOrUnclaimed(bool claimed, wtf_size_t interface_index); |
| void AsyncSelectAlternateInterface(wtf_size_t interface_index, |
| wtf_size_t alternate_index, |
| ScriptPromiseResolver<IDLUndefined>*, |
| bool success); |
| void AsyncControlTransferIn(ScriptPromiseResolver<USBInTransferResult>*, |
| device::mojom::blink::UsbTransferStatus, |
| base::span<const uint8_t> data); |
| void AsyncControlTransferOut(uint32_t transfer_length, |
| ScriptPromiseResolver<USBOutTransferResult>*, |
| device::mojom::blink::UsbTransferStatus); |
| void AsyncClearHalt(ScriptPromiseResolver<IDLUndefined>*, bool success); |
| void AsyncTransferIn(ScriptPromiseResolver<USBInTransferResult>*, |
| device::mojom::blink::UsbTransferStatus, |
| base::span<const uint8_t> data); |
| void AsyncTransferOut(uint32_t transfer_length, |
| ScriptPromiseResolver<USBOutTransferResult>*, |
| device::mojom::blink::UsbTransferStatus); |
| void AsyncIsochronousTransferIn( |
| ScriptPromiseResolver<USBIsochronousInTransferResult>*, |
| base::span<const uint8_t> data, |
| Vector<device::mojom::blink::UsbIsochronousPacketPtr>); |
| void AsyncIsochronousTransferOut( |
| ScriptPromiseResolver<USBIsochronousOutTransferResult>*, |
| Vector<device::mojom::blink::UsbIsochronousPacketPtr>); |
| void AsyncReset(ScriptPromiseResolver<IDLUndefined>*, bool success); |
| |
| void OnConnectionError(); |
| void MarkRequestComplete(ScriptPromiseResolverBase*); |
| |
| const Member<USB> parent_; |
| device::mojom::blink::UsbDeviceInfoPtr device_info_; |
| HeapMojoRemote<device::mojom::blink::UsbDevice> device_; |
| HeapHashSet<Member<ScriptPromiseResolverBase>> device_requests_; |
| HeapVector<Member<USBConfiguration>> configurations_; |
| bool opened_; |
| bool device_state_change_in_progress_; |
| wtf_size_t configuration_index_; |
| |
| // These vectors have one entry for each interface in the currently selected |
| // configured. Use the index returned by FindInterfaceIndex(). |
| Vector<bool> claimed_interfaces_; |
| Vector<bool> interface_state_change_in_progress_; |
| Vector<wtf_size_t> selected_alternate_indices_; |
| |
| // These bit sets have one entry for each endpoint. Index using the endpoint |
| // number (lower 4 bits of the endpoint address). |
| std::bitset<kEndpointsBitsNumber> in_endpoints_; |
| std::bitset<kEndpointsBitsNumber> out_endpoints_; |
| }; |
| |
| } // namespace blink |
| |
| #endif // THIRD_PARTY_BLINK_RENDERER_MODULES_WEBUSB_USB_DEVICE_H_ |
