OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "modules/webusb/USBDevice.h" | 5 #include "modules/webusb/USBDevice.h" |
6 | 6 |
7 #include "bindings/core/v8/ScriptPromise.h" | 7 #include "bindings/core/v8/ScriptPromise.h" |
8 #include "bindings/core/v8/ScriptPromiseResolver.h" | 8 #include "bindings/core/v8/ScriptPromiseResolver.h" |
9 #include "bindings/core/v8/ToV8ForCore.h" | 9 #include "bindings/core/v8/ToV8ForCore.h" |
10 #include "core/dom/DOMArrayBuffer.h" | 10 #include "core/dom/DOMArrayBuffer.h" |
11 #include "core/dom/DOMArrayBufferView.h" | 11 #include "core/dom/DOMArrayBufferView.h" |
12 #include "core/dom/DOMException.h" | 12 #include "core/dom/DOMException.h" |
13 #include "core/dom/ExceptionCode.h" | 13 #include "core/dom/ExceptionCode.h" |
14 #include "modules/webusb/USBConfiguration.h" | 14 #include "modules/webusb/USBConfiguration.h" |
15 #include "modules/webusb/USBControlTransferParameters.h" | 15 #include "modules/webusb/USBControlTransferParameters.h" |
16 #include "modules/webusb/USBInTransferResult.h" | 16 #include "modules/webusb/USBInTransferResult.h" |
17 #include "modules/webusb/USBIsochronousInTransferResult.h" | 17 #include "modules/webusb/USBIsochronousInTransferResult.h" |
18 #include "modules/webusb/USBIsochronousOutTransferResult.h" | 18 #include "modules/webusb/USBIsochronousOutTransferResult.h" |
19 #include "modules/webusb/USBOutTransferResult.h" | 19 #include "modules/webusb/USBOutTransferResult.h" |
20 #include "platform/mojo/MojoHelper.h" | 20 #include "platform/mojo/MojoHelper.h" |
21 #include "platform/wtf/Assertions.h" | 21 #include "platform/wtf/Assertions.h" |
22 #include "public/platform/Platform.h" | 22 #include "public/platform/Platform.h" |
23 | 23 |
24 namespace usb = device::usb::blink; | 24 using device::mojom::blink::UsbControlTransferParamsPtr; |
| 25 using device::mojom::blink::UsbControlTransferType; |
| 26 using device::mojom::blink::UsbControlTransferRecipient; |
| 27 using device::mojom::blink::UsbDeviceInfoPtr; |
| 28 using device::mojom::blink::UsbDevicePtr; |
| 29 using device::mojom::blink::UsbIsochronousPacketPtr; |
| 30 using device::mojom::blink::UsbOpenDeviceError; |
| 31 using device::mojom::blink::UsbTransferDirection; |
| 32 using device::mojom::blink::UsbTransferStatus; |
25 | 33 |
26 namespace blink { | 34 namespace blink { |
27 | 35 |
28 namespace { | 36 namespace { |
29 | 37 |
30 const char kDeviceStateChangeInProgress[] = | 38 const char kDeviceStateChangeInProgress[] = |
31 "An operation that changes the device state is in progress."; | 39 "An operation that changes the device state is in progress."; |
32 const char kDeviceUnavailable[] = "Device unavailable."; | 40 const char kDeviceUnavailable[] = "Device unavailable."; |
33 const char kInterfaceNotFound[] = | 41 const char kInterfaceNotFound[] = |
34 "The interface number provided is not supported by the device in its " | 42 "The interface number provided is not supported by the device in its " |
35 "current configuration."; | 43 "current configuration."; |
36 const char kInterfaceStateChangeInProgress[] = | 44 const char kInterfaceStateChangeInProgress[] = |
37 "An operation that changes interface state is in progress."; | 45 "An operation that changes interface state is in progress."; |
38 const char kOpenRequired[] = "The device must be opened first."; | 46 const char kOpenRequired[] = "The device must be opened first."; |
39 | 47 |
40 DOMException* ConvertFatalTransferStatus(const usb::TransferStatus& status) { | 48 DOMException* ConvertFatalTransferStatus(const UsbTransferStatus& status) { |
41 switch (status) { | 49 switch (status) { |
42 case usb::TransferStatus::TRANSFER_ERROR: | 50 case UsbTransferStatus::TRANSFER_ERROR: |
43 return DOMException::Create(kNetworkError, | 51 return DOMException::Create(kNetworkError, |
44 "A transfer error has occured."); | 52 "A transfer error has occured."); |
45 case usb::TransferStatus::PERMISSION_DENIED: | 53 case UsbTransferStatus::PERMISSION_DENIED: |
46 return DOMException::Create(kSecurityError, | 54 return DOMException::Create(kSecurityError, |
47 "The transfer was not allowed."); | 55 "The transfer was not allowed."); |
48 case usb::TransferStatus::TIMEOUT: | 56 case UsbTransferStatus::TIMEOUT: |
49 return DOMException::Create(kTimeoutError, "The transfer timed out."); | 57 return DOMException::Create(kTimeoutError, "The transfer timed out."); |
50 case usb::TransferStatus::CANCELLED: | 58 case UsbTransferStatus::CANCELLED: |
51 return DOMException::Create(kAbortError, "The transfer was cancelled."); | 59 return DOMException::Create(kAbortError, "The transfer was cancelled."); |
52 case usb::TransferStatus::DISCONNECT: | 60 case UsbTransferStatus::DISCONNECT: |
53 return DOMException::Create(kNotFoundError, kDeviceUnavailable); | 61 return DOMException::Create(kNotFoundError, kDeviceUnavailable); |
54 case usb::TransferStatus::COMPLETED: | 62 case UsbTransferStatus::COMPLETED: |
55 case usb::TransferStatus::STALLED: | 63 case UsbTransferStatus::STALLED: |
56 case usb::TransferStatus::BABBLE: | 64 case UsbTransferStatus::BABBLE: |
57 case usb::TransferStatus::SHORT_PACKET: | 65 case UsbTransferStatus::SHORT_PACKET: |
58 return nullptr; | 66 return nullptr; |
59 default: | 67 default: |
60 ASSERT_NOT_REACHED(); | 68 ASSERT_NOT_REACHED(); |
61 return nullptr; | 69 return nullptr; |
62 } | 70 } |
63 } | 71 } |
64 | 72 |
65 String ConvertTransferStatus(const usb::TransferStatus& status) { | 73 String ConvertTransferStatus(const UsbTransferStatus& status) { |
66 switch (status) { | 74 switch (status) { |
67 case usb::TransferStatus::COMPLETED: | 75 case UsbTransferStatus::COMPLETED: |
68 case usb::TransferStatus::SHORT_PACKET: | 76 case UsbTransferStatus::SHORT_PACKET: |
69 return "ok"; | 77 return "ok"; |
70 case usb::TransferStatus::STALLED: | 78 case UsbTransferStatus::STALLED: |
71 return "stall"; | 79 return "stall"; |
72 case usb::TransferStatus::BABBLE: | 80 case UsbTransferStatus::BABBLE: |
73 return "babble"; | 81 return "babble"; |
74 default: | 82 default: |
75 ASSERT_NOT_REACHED(); | 83 ASSERT_NOT_REACHED(); |
76 return ""; | 84 return ""; |
77 } | 85 } |
78 } | 86 } |
79 | 87 |
80 Vector<uint8_t> ConvertBufferSource( | 88 Vector<uint8_t> ConvertBufferSource( |
81 const ArrayBufferOrArrayBufferView& buffer) { | 89 const ArrayBufferOrArrayBufferView& buffer) { |
82 ASSERT(!buffer.isNull()); | 90 ASSERT(!buffer.isNull()); |
83 Vector<uint8_t> vector; | 91 Vector<uint8_t> vector; |
84 if (buffer.isArrayBuffer()) | 92 if (buffer.isArrayBuffer()) |
85 vector.Append(static_cast<uint8_t*>(buffer.getAsArrayBuffer()->Data()), | 93 vector.Append(static_cast<uint8_t*>(buffer.getAsArrayBuffer()->Data()), |
86 buffer.getAsArrayBuffer()->ByteLength()); | 94 buffer.getAsArrayBuffer()->ByteLength()); |
87 else | 95 else |
88 vector.Append(static_cast<uint8_t*>( | 96 vector.Append(static_cast<uint8_t*>( |
89 buffer.getAsArrayBufferView().View()->BaseAddress()), | 97 buffer.getAsArrayBufferView().View()->BaseAddress()), |
90 buffer.getAsArrayBufferView().View()->byteLength()); | 98 buffer.getAsArrayBufferView().View()->byteLength()); |
91 return vector; | 99 return vector; |
92 } | 100 } |
93 | 101 |
94 } // namespace | 102 } // namespace |
95 | 103 |
96 USBDevice::USBDevice(usb::DeviceInfoPtr device_info, | 104 USBDevice::USBDevice(UsbDeviceInfoPtr device_info, |
97 usb::DevicePtr device, | 105 UsbDevicePtr device, |
98 ExecutionContext* context) | 106 ExecutionContext* context) |
99 : ContextLifecycleObserver(context), | 107 : ContextLifecycleObserver(context), |
100 device_info_(std::move(device_info)), | 108 device_info_(std::move(device_info)), |
101 device_(std::move(device)), | 109 device_(std::move(device)), |
102 opened_(false), | 110 opened_(false), |
103 device_state_change_in_progress_(false), | 111 device_state_change_in_progress_(false), |
104 configuration_index_(-1) { | 112 configuration_index_(-1) { |
105 if (device_) { | 113 if (device_) { |
106 device_.set_connection_error_handler(ConvertToBaseCallback( | 114 device_.set_connection_error_handler(ConvertToBaseCallback( |
107 WTF::Bind(&USBDevice::OnConnectionError, WrapWeakPersistent(this)))); | 115 WTF::Bind(&USBDevice::OnConnectionError, WrapWeakPersistent(this)))); |
(...skipping 465 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
573 } | 581 } |
574 | 582 |
575 bool USBDevice::AnyInterfaceChangeInProgress() const { | 583 bool USBDevice::AnyInterfaceChangeInProgress() const { |
576 for (size_t i = 0; i < interface_state_change_in_progress_.size(); ++i) { | 584 for (size_t i = 0; i < interface_state_change_in_progress_.size(); ++i) { |
577 if (interface_state_change_in_progress_.QuickGet(i)) | 585 if (interface_state_change_in_progress_.QuickGet(i)) |
578 return true; | 586 return true; |
579 } | 587 } |
580 return false; | 588 return false; |
581 } | 589 } |
582 | 590 |
583 usb::ControlTransferParamsPtr USBDevice::ConvertControlTransferParameters( | 591 UsbControlTransferParamsPtr USBDevice::ConvertControlTransferParameters( |
584 const USBControlTransferParameters& parameters, | 592 const USBControlTransferParameters& parameters, |
585 ScriptPromiseResolver* resolver) const { | 593 ScriptPromiseResolver* resolver) const { |
586 auto mojo_parameters = usb::ControlTransferParams::New(); | 594 auto mojo_parameters = device::mojom::blink::UsbControlTransferParams::New(); |
587 | 595 |
588 if (parameters.requestType() == "standard") { | 596 if (parameters.requestType() == "standard") { |
589 mojo_parameters->type = usb::ControlTransferType::STANDARD; | 597 mojo_parameters->type = UsbControlTransferType::STANDARD; |
590 } else if (parameters.requestType() == "class") { | 598 } else if (parameters.requestType() == "class") { |
591 mojo_parameters->type = usb::ControlTransferType::CLASS; | 599 mojo_parameters->type = UsbControlTransferType::CLASS; |
592 } else if (parameters.requestType() == "vendor") { | 600 } else if (parameters.requestType() == "vendor") { |
593 mojo_parameters->type = usb::ControlTransferType::VENDOR; | 601 mojo_parameters->type = UsbControlTransferType::VENDOR; |
594 } else { | 602 } else { |
595 resolver->Reject(DOMException::Create( | 603 resolver->Reject(DOMException::Create( |
596 kTypeMismatchError, | 604 kTypeMismatchError, |
597 "The control transfer requestType parameter is invalid.")); | 605 "The control transfer requestType parameter is invalid.")); |
598 return nullptr; | 606 return nullptr; |
599 } | 607 } |
600 | 608 |
601 if (parameters.recipient() == "device") { | 609 if (parameters.recipient() == "device") { |
602 mojo_parameters->recipient = usb::ControlTransferRecipient::DEVICE; | 610 mojo_parameters->recipient = UsbControlTransferRecipient::DEVICE; |
603 } else if (parameters.recipient() == "interface") { | 611 } else if (parameters.recipient() == "interface") { |
604 size_t interface_number = parameters.index() & 0xff; | 612 size_t interface_number = parameters.index() & 0xff; |
605 if (!EnsureInterfaceClaimed(interface_number, resolver)) | 613 if (!EnsureInterfaceClaimed(interface_number, resolver)) |
606 return nullptr; | 614 return nullptr; |
607 mojo_parameters->recipient = usb::ControlTransferRecipient::INTERFACE; | 615 mojo_parameters->recipient = UsbControlTransferRecipient::INTERFACE; |
608 } else if (parameters.recipient() == "endpoint") { | 616 } else if (parameters.recipient() == "endpoint") { |
609 bool in_transfer = parameters.index() & 0x80; | 617 bool in_transfer = parameters.index() & 0x80; |
610 size_t endpoint_number = parameters.index() & 0x0f; | 618 size_t endpoint_number = parameters.index() & 0x0f; |
611 if (!EnsureEndpointAvailable(in_transfer, endpoint_number, resolver)) | 619 if (!EnsureEndpointAvailable(in_transfer, endpoint_number, resolver)) |
612 return nullptr; | 620 return nullptr; |
613 mojo_parameters->recipient = usb::ControlTransferRecipient::ENDPOINT; | 621 mojo_parameters->recipient = UsbControlTransferRecipient::ENDPOINT; |
614 } else if (parameters.recipient() == "other") { | 622 } else if (parameters.recipient() == "other") { |
615 mojo_parameters->recipient = usb::ControlTransferRecipient::OTHER; | 623 mojo_parameters->recipient = UsbControlTransferRecipient::OTHER; |
616 } else { | 624 } else { |
617 resolver->Reject(DOMException::Create( | 625 resolver->Reject(DOMException::Create( |
618 kTypeMismatchError, | 626 kTypeMismatchError, |
619 "The control transfer recipient parameter is invalid.")); | 627 "The control transfer recipient parameter is invalid.")); |
620 return nullptr; | 628 return nullptr; |
621 } | 629 } |
622 | 630 |
623 mojo_parameters->request = parameters.request(); | 631 mojo_parameters->request = parameters.request(); |
624 mojo_parameters->value = parameters.value(); | 632 mojo_parameters->value = parameters.value(); |
625 mojo_parameters->index = parameters.index(); | 633 mojo_parameters->index = parameters.index(); |
626 return mojo_parameters; | 634 return mojo_parameters; |
627 } | 635 } |
628 | 636 |
629 void USBDevice::SetEndpointsForInterface(size_t interface_index, bool set) { | 637 void USBDevice::SetEndpointsForInterface(size_t interface_index, bool set) { |
630 const auto& configuration = *Info().configurations[configuration_index_]; | 638 const auto& configuration = *Info().configurations[configuration_index_]; |
631 const auto& interface = *configuration.interfaces[interface_index]; | 639 const auto& interface = *configuration.interfaces[interface_index]; |
632 const auto& alternate = | 640 const auto& alternate = |
633 *interface.alternates[selected_alternates_[interface_index]]; | 641 *interface.alternates[selected_alternates_[interface_index]]; |
634 for (const auto& endpoint : alternate.endpoints) { | 642 for (const auto& endpoint : alternate.endpoints) { |
635 uint8_t endpoint_number = endpoint->endpoint_number; | 643 uint8_t endpoint_number = endpoint->endpoint_number; |
636 if (endpoint_number == 0 || endpoint_number >= 16) | 644 if (endpoint_number == 0 || endpoint_number >= 16) |
637 continue; // Ignore endpoints with invalid indices. | 645 continue; // Ignore endpoints with invalid indices. |
638 auto& bit_vector = endpoint->direction == usb::TransferDirection::INBOUND | 646 auto& bit_vector = endpoint->direction == UsbTransferDirection::INBOUND |
639 ? in_endpoints_ | 647 ? in_endpoints_ |
640 : out_endpoints_; | 648 : out_endpoints_; |
641 if (set) | 649 if (set) |
642 bit_vector.Set(endpoint_number - 1); | 650 bit_vector.Set(endpoint_number - 1); |
643 else | 651 else |
644 bit_vector.Clear(endpoint_number - 1); | 652 bit_vector.Clear(endpoint_number - 1); |
645 } | 653 } |
646 } | 654 } |
647 | 655 |
648 void USBDevice::AsyncOpen(ScriptPromiseResolver* resolver, | 656 void USBDevice::AsyncOpen(ScriptPromiseResolver* resolver, |
649 usb::OpenDeviceError error) { | 657 UsbOpenDeviceError error) { |
650 if (!MarkRequestComplete(resolver)) | 658 if (!MarkRequestComplete(resolver)) |
651 return; | 659 return; |
652 | 660 |
653 switch (error) { | 661 switch (error) { |
654 case usb::OpenDeviceError::ALREADY_OPEN: | 662 case UsbOpenDeviceError::ALREADY_OPEN: |
655 ASSERT_NOT_REACHED(); | 663 ASSERT_NOT_REACHED(); |
656 // fall through | 664 // fall through |
657 case usb::OpenDeviceError::OK: | 665 case UsbOpenDeviceError::OK: |
658 OnDeviceOpenedOrClosed(true /* opened */); | 666 OnDeviceOpenedOrClosed(true /* opened */); |
659 resolver->Resolve(); | 667 resolver->Resolve(); |
660 return; | 668 return; |
661 case usb::OpenDeviceError::ACCESS_DENIED: | 669 case UsbOpenDeviceError::ACCESS_DENIED: |
662 OnDeviceOpenedOrClosed(false /* not opened */); | 670 OnDeviceOpenedOrClosed(false /* not opened */); |
663 resolver->Reject(DOMException::Create(kSecurityError, "Access denied.")); | 671 resolver->Reject(DOMException::Create(kSecurityError, "Access denied.")); |
664 return; | 672 return; |
665 } | 673 } |
666 } | 674 } |
667 | 675 |
668 void USBDevice::AsyncClose(ScriptPromiseResolver* resolver) { | 676 void USBDevice::AsyncClose(ScriptPromiseResolver* resolver) { |
669 if (!MarkRequestComplete(resolver)) | 677 if (!MarkRequestComplete(resolver)) |
670 return; | 678 return; |
671 | 679 |
(...skipping 97 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
769 interface_state_change_in_progress_.Clear(interface_index); | 777 interface_state_change_in_progress_.Clear(interface_index); |
770 | 778 |
771 if (success) | 779 if (success) |
772 resolver->Resolve(); | 780 resolver->Resolve(); |
773 else | 781 else |
774 resolver->Reject( | 782 resolver->Reject( |
775 DOMException::Create(kNetworkError, "Unable to set device interface.")); | 783 DOMException::Create(kNetworkError, "Unable to set device interface.")); |
776 } | 784 } |
777 | 785 |
778 void USBDevice::AsyncControlTransferIn(ScriptPromiseResolver* resolver, | 786 void USBDevice::AsyncControlTransferIn(ScriptPromiseResolver* resolver, |
779 usb::TransferStatus status, | 787 UsbTransferStatus status, |
780 const Optional<Vector<uint8_t>>& data) { | 788 const Optional<Vector<uint8_t>>& data) { |
781 if (!MarkRequestComplete(resolver)) | 789 if (!MarkRequestComplete(resolver)) |
782 return; | 790 return; |
783 | 791 |
784 DOMException* error = ConvertFatalTransferStatus(status); | 792 DOMException* error = ConvertFatalTransferStatus(status); |
785 if (error) { | 793 if (error) { |
786 resolver->Reject(error); | 794 resolver->Reject(error); |
787 } else { | 795 } else { |
788 resolver->Resolve( | 796 resolver->Resolve( |
789 USBInTransferResult::Create(ConvertTransferStatus(status), data)); | 797 USBInTransferResult::Create(ConvertTransferStatus(status), data)); |
790 } | 798 } |
791 } | 799 } |
792 | 800 |
793 void USBDevice::AsyncControlTransferOut(unsigned transfer_length, | 801 void USBDevice::AsyncControlTransferOut(unsigned transfer_length, |
794 ScriptPromiseResolver* resolver, | 802 ScriptPromiseResolver* resolver, |
795 usb::TransferStatus status) { | 803 UsbTransferStatus status) { |
796 if (!MarkRequestComplete(resolver)) | 804 if (!MarkRequestComplete(resolver)) |
797 return; | 805 return; |
798 | 806 |
799 DOMException* error = ConvertFatalTransferStatus(status); | 807 DOMException* error = ConvertFatalTransferStatus(status); |
800 if (error) { | 808 if (error) { |
801 resolver->Reject(error); | 809 resolver->Reject(error); |
802 } else { | 810 } else { |
803 resolver->Resolve(USBOutTransferResult::Create( | 811 resolver->Resolve(USBOutTransferResult::Create( |
804 ConvertTransferStatus(status), transfer_length)); | 812 ConvertTransferStatus(status), transfer_length)); |
805 } | 813 } |
806 } | 814 } |
807 | 815 |
808 void USBDevice::AsyncClearHalt(ScriptPromiseResolver* resolver, bool success) { | 816 void USBDevice::AsyncClearHalt(ScriptPromiseResolver* resolver, bool success) { |
809 if (!MarkRequestComplete(resolver)) | 817 if (!MarkRequestComplete(resolver)) |
810 return; | 818 return; |
811 | 819 |
812 if (success) | 820 if (success) |
813 resolver->Resolve(); | 821 resolver->Resolve(); |
814 else | 822 else |
815 resolver->Reject( | 823 resolver->Reject( |
816 DOMException::Create(kNetworkError, "Unable to clear endpoint.")); | 824 DOMException::Create(kNetworkError, "Unable to clear endpoint.")); |
817 } | 825 } |
818 | 826 |
819 void USBDevice::AsyncTransferIn(ScriptPromiseResolver* resolver, | 827 void USBDevice::AsyncTransferIn(ScriptPromiseResolver* resolver, |
820 usb::TransferStatus status, | 828 UsbTransferStatus status, |
821 const Optional<Vector<uint8_t>>& data) { | 829 const Optional<Vector<uint8_t>>& data) { |
822 if (!MarkRequestComplete(resolver)) | 830 if (!MarkRequestComplete(resolver)) |
823 return; | 831 return; |
824 | 832 |
825 DOMException* error = ConvertFatalTransferStatus(status); | 833 DOMException* error = ConvertFatalTransferStatus(status); |
826 if (error) { | 834 if (error) { |
827 resolver->Reject(error); | 835 resolver->Reject(error); |
828 } else { | 836 } else { |
829 resolver->Resolve( | 837 resolver->Resolve( |
830 USBInTransferResult::Create(ConvertTransferStatus(status), data)); | 838 USBInTransferResult::Create(ConvertTransferStatus(status), data)); |
831 } | 839 } |
832 } | 840 } |
833 | 841 |
834 void USBDevice::AsyncTransferOut(unsigned transfer_length, | 842 void USBDevice::AsyncTransferOut(unsigned transfer_length, |
835 ScriptPromiseResolver* resolver, | 843 ScriptPromiseResolver* resolver, |
836 usb::TransferStatus status) { | 844 UsbTransferStatus status) { |
837 if (!MarkRequestComplete(resolver)) | 845 if (!MarkRequestComplete(resolver)) |
838 return; | 846 return; |
839 | 847 |
840 DOMException* error = ConvertFatalTransferStatus(status); | 848 DOMException* error = ConvertFatalTransferStatus(status); |
841 if (error) { | 849 if (error) { |
842 resolver->Reject(error); | 850 resolver->Reject(error); |
843 } else { | 851 } else { |
844 resolver->Resolve(USBOutTransferResult::Create( | 852 resolver->Resolve(USBOutTransferResult::Create( |
845 ConvertTransferStatus(status), transfer_length)); | 853 ConvertTransferStatus(status), transfer_length)); |
846 } | 854 } |
847 } | 855 } |
848 | 856 |
849 void USBDevice::AsyncIsochronousTransferIn( | 857 void USBDevice::AsyncIsochronousTransferIn( |
850 ScriptPromiseResolver* resolver, | 858 ScriptPromiseResolver* resolver, |
851 const Optional<Vector<uint8_t>>& data, | 859 const Optional<Vector<uint8_t>>& data, |
852 Vector<usb::IsochronousPacketPtr> mojo_packets) { | 860 Vector<UsbIsochronousPacketPtr> mojo_packets) { |
853 if (!MarkRequestComplete(resolver)) | 861 if (!MarkRequestComplete(resolver)) |
854 return; | 862 return; |
855 | 863 |
856 DOMArrayBuffer* buffer = | 864 DOMArrayBuffer* buffer = |
857 data ? DOMArrayBuffer::Create(data->Data(), data->size()) : nullptr; | 865 data ? DOMArrayBuffer::Create(data->Data(), data->size()) : nullptr; |
858 HeapVector<Member<USBIsochronousInTransferPacket>> packets; | 866 HeapVector<Member<USBIsochronousInTransferPacket>> packets; |
859 packets.ReserveCapacity(mojo_packets.size()); | 867 packets.ReserveCapacity(mojo_packets.size()); |
860 size_t byte_offset = 0; | 868 size_t byte_offset = 0; |
861 for (const auto& packet : mojo_packets) { | 869 for (const auto& packet : mojo_packets) { |
862 DOMException* error = ConvertFatalTransferStatus(packet->status); | 870 DOMException* error = ConvertFatalTransferStatus(packet->status); |
863 if (error) { | 871 if (error) { |
864 resolver->Reject(error); | 872 resolver->Reject(error); |
865 return; | 873 return; |
866 } | 874 } |
867 DOMDataView* data_view = nullptr; | 875 DOMDataView* data_view = nullptr; |
868 if (buffer) { | 876 if (buffer) { |
869 data_view = | 877 data_view = |
870 DOMDataView::Create(buffer, byte_offset, packet->transferred_length); | 878 DOMDataView::Create(buffer, byte_offset, packet->transferred_length); |
871 } | 879 } |
872 packets.push_back(USBIsochronousInTransferPacket::Create( | 880 packets.push_back(USBIsochronousInTransferPacket::Create( |
873 ConvertTransferStatus(packet->status), data_view)); | 881 ConvertTransferStatus(packet->status), data_view)); |
874 byte_offset += packet->length; | 882 byte_offset += packet->length; |
875 } | 883 } |
876 resolver->Resolve(USBIsochronousInTransferResult::Create(buffer, packets)); | 884 resolver->Resolve(USBIsochronousInTransferResult::Create(buffer, packets)); |
877 } | 885 } |
878 | 886 |
879 void USBDevice::AsyncIsochronousTransferOut( | 887 void USBDevice::AsyncIsochronousTransferOut( |
880 ScriptPromiseResolver* resolver, | 888 ScriptPromiseResolver* resolver, |
881 Vector<usb::IsochronousPacketPtr> mojo_packets) { | 889 Vector<UsbIsochronousPacketPtr> mojo_packets) { |
882 if (!MarkRequestComplete(resolver)) | 890 if (!MarkRequestComplete(resolver)) |
883 return; | 891 return; |
884 | 892 |
885 HeapVector<Member<USBIsochronousOutTransferPacket>> packets; | 893 HeapVector<Member<USBIsochronousOutTransferPacket>> packets; |
886 packets.ReserveCapacity(mojo_packets.size()); | 894 packets.ReserveCapacity(mojo_packets.size()); |
887 for (const auto& packet : mojo_packets) { | 895 for (const auto& packet : mojo_packets) { |
888 DOMException* error = ConvertFatalTransferStatus(packet->status); | 896 DOMException* error = ConvertFatalTransferStatus(packet->status); |
889 if (error) { | 897 if (error) { |
890 resolver->Reject(error); | 898 resolver->Reject(error); |
891 return; | 899 return; |
(...skipping 25 matching lines...) Expand all Loading... |
917 | 925 |
918 bool USBDevice::MarkRequestComplete(ScriptPromiseResolver* resolver) { | 926 bool USBDevice::MarkRequestComplete(ScriptPromiseResolver* resolver) { |
919 auto request_entry = device_requests_.Find(resolver); | 927 auto request_entry = device_requests_.Find(resolver); |
920 if (request_entry == device_requests_.end()) | 928 if (request_entry == device_requests_.end()) |
921 return false; | 929 return false; |
922 device_requests_.erase(request_entry); | 930 device_requests_.erase(request_entry); |
923 return true; | 931 return true; |
924 } | 932 } |
925 | 933 |
926 } // namespace blink | 934 } // namespace blink |
OLD | NEW |