OLD | NEW |
---|---|
(Empty) | |
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 | |
3 // found in the LICENSE file. | |
4 | |
5 #include "config.h" | |
6 #include "modules/webusb/USBDevice.h" | |
7 | |
8 #include "bindings/core/v8/CallbackPromiseAdapter.h" | |
9 #include "bindings/core/v8/ScriptPromise.h" | |
10 #include "bindings/core/v8/ScriptPromiseResolver.h" | |
11 #include "bindings/core/v8/ToV8.h" | |
12 #include "core/dom/DOMArrayBuffer.h" | |
13 #include "core/dom/DOMArrayBufferView.h" | |
14 #include "core/dom/DOMException.h" | |
15 #include "modules/webusb/USBControlTransferParameters.h" | |
16 #include "modules/webusb/USBError.h" | |
17 #include "modules/webusb/USBInTransferResult.h" | |
18 #include "modules/webusb/USBOutTransferResult.h" | |
19 #include "public/platform/modules/webusb/WebUSBTransferInfo.h" | |
20 | |
21 namespace blink { | |
22 | |
23 namespace { | |
24 | |
25 WebUSBDevice::ControlTransferParameters ConvertControlTransferParameters( | |
26 WebUSBDevice::TransferDirection direction, | |
27 const USBControlTransferParameters& parameters) | |
28 { | |
29 WebUSBDevice::ControlTransferParameters webParameters; | |
30 webParameters.direction = direction; | |
31 | |
32 if (parameters.requestType() == "standard") | |
33 webParameters.type = WebUSBDevice::RequestTypeStandard; | |
34 else if (parameters.requestType() == "class") | |
35 webParameters.type = WebUSBDevice::RequestTypeClass; | |
36 else if (parameters.requestType() == "vendor") | |
37 webParameters.type = WebUSBDevice::RequestTypeVendor; | |
38 else | |
39 webParameters.type = WebUSBDevice::RequestTypeStandard; | |
Reilly Grant (use Gerrit)
2015/07/23 23:24:08
We should be raising a DOMException if the request
Ken Rockot(use gerrit already)
2015/07/28 22:30:38
Done.
| |
40 | |
41 if (parameters.recipient() == "device") | |
42 webParameters.recipient = WebUSBDevice::RequestRecipientDevice; | |
43 else if (parameters.recipient() == "interface") | |
44 webParameters.recipient = WebUSBDevice::RequestRecipientInterface; | |
45 else if (parameters.recipient() == "endpoint") | |
46 webParameters.recipient = WebUSBDevice::RequestRecipientEndpoint; | |
47 else | |
48 webParameters.recipient = WebUSBDevice::RequestRecipientDevice; | |
Reilly Grant (use Gerrit)
2015/07/23 23:24:08
We should be raising a DOMException if the recipie
Ken Rockot(use gerrit already)
2015/07/28 22:30:38
Done.
| |
49 | |
50 webParameters.request = parameters.request(); | |
51 webParameters.value = parameters.value(); | |
52 | |
53 if (parameters.hasIndex()) | |
Reilly Grant (use Gerrit)
2015/07/23 23:24:08
This is a required field.
Ken Rockot(use gerrit already)
2015/07/28 22:30:38
Done.
| |
54 webParameters.index = parameters.index(); | |
55 else | |
56 webParameters.index = 0; | |
57 | |
58 return webParameters; | |
59 } | |
60 | |
61 String ConvertTransferStatus(const WebUSBTransferInfo::Status& status) | |
62 { | |
63 switch (status) { | |
64 case WebUSBTransferInfo::StatusOk: | |
65 return "ok"; | |
66 case WebUSBTransferInfo::StatusStalled: | |
67 return "stall"; | |
68 case WebUSBTransferInfo::StatusOverflow: | |
69 return "babble"; | |
70 default: | |
71 ASSERT_NOT_REACHED(); | |
72 return ""; | |
73 } | |
74 } | |
75 | |
76 class InputTransferResult { | |
77 WTF_MAKE_NONCOPYABLE(InputTransferResult); | |
78 public: | |
79 using WebType = WebUSBTransferInfo; | |
80 | |
81 static USBInTransferResult* take(ScriptPromiseResolver*, PassOwnPtr<WebType> webTransferInfo) | |
82 { | |
83 return USBInTransferResult::create( | |
84 ConvertTransferStatus(webTransferInfo->status), | |
85 DOMArrayBuffer::create(webTransferInfo->data.data(), webTransferInfo ->data.size())); | |
86 } | |
87 | |
88 private: | |
89 InputTransferResult() = delete; | |
90 }; | |
91 | |
92 class OutputTransferResult { | |
93 WTF_MAKE_NONCOPYABLE(OutputTransferResult); | |
94 public: | |
95 using WebType = WebUSBTransferInfo; | |
96 | |
97 static USBOutTransferResult* take(ScriptPromiseResolver*, PassOwnPtr<WebType > webTransferInfo) | |
98 { | |
99 return USBOutTransferResult::create(ConvertTransferStatus(webTransferInf o->status), webTransferInfo->bytesSent); | |
100 } | |
101 | |
102 private: | |
103 OutputTransferResult() = delete; | |
104 }; | |
105 | |
106 class BufferSource { | |
107 WTF_MAKE_NONCOPYABLE(BufferSource); | |
108 public: | |
109 BufferSource(const ArrayBufferOrArrayBufferView& buffer) : m_buffer(buffer) { } | |
110 | |
111 uint8_t* data() const | |
112 { | |
113 if (m_buffer.isArrayBuffer()) | |
114 return static_cast<uint8_t*>(m_buffer.getAsArrayBuffer()->data()); | |
115 return static_cast<uint8_t*>(m_buffer.getAsArrayBufferView()->baseAddres s()); | |
116 } | |
117 | |
118 unsigned size() const | |
119 { | |
120 if (m_buffer.isArrayBuffer()) | |
121 return m_buffer.getAsArrayBuffer()->byteLength(); | |
122 return m_buffer.getAsArrayBufferView()->byteLength(); | |
123 } | |
124 | |
125 private: | |
126 const ArrayBufferOrArrayBufferView& m_buffer; | |
127 }; | |
128 | |
129 } // namespace | |
130 | |
131 // static | |
132 USBDevice* USBDevice::create(PassOwnPtr<WebUSBDevice> device) | |
133 { | |
134 return new USBDevice(device); | |
135 } | |
136 | |
137 USBDevice::USBDevice(PassOwnPtr<WebUSBDevice> device) | |
138 : m_device(device) | |
139 { | |
140 } | |
141 | |
142 HeapVector<Member<USBConfiguration>> USBDevice::configurations() const | |
143 { | |
144 HeapVector<Member<USBConfiguration>> configurations; | |
145 for (size_t i = 0; i < info().configurations.size(); ++i) | |
146 configurations.append(USBConfiguration::create(this, i)); | |
147 return configurations; | |
148 } | |
149 | |
150 ScriptPromise USBDevice::open(ScriptState* scriptState) | |
151 { | |
152 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver:: create(scriptState); | |
153 ScriptPromise promise = resolver->promise(); | |
154 m_device->open(new CallbackPromiseAdapter<void, USBError>(resolver)); | |
155 return promise; | |
156 } | |
157 | |
158 ScriptPromise USBDevice::close(ScriptState* scriptState) | |
159 { | |
160 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver:: create(scriptState); | |
161 ScriptPromise promise = resolver->promise(); | |
162 m_device->close(new CallbackPromiseAdapter<void, USBError>(resolver)); | |
163 return promise; | |
164 } | |
165 | |
166 ScriptPromise USBDevice::setConfiguration(ScriptState* scriptState, uint8_t conf igurationValue) | |
167 { | |
168 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver:: create(scriptState); | |
169 ScriptPromise promise = resolver->promise(); | |
170 m_device->setConfiguration(configurationValue, new CallbackPromiseAdapter<vo id, USBError>(resolver)); | |
171 return promise; | |
172 } | |
173 | |
174 ScriptPromise USBDevice::claimInterface(ScriptState* scriptState, uint8_t interf aceNumber) | |
175 { | |
176 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver:: create(scriptState); | |
177 ScriptPromise promise = resolver->promise(); | |
178 m_device->claimInterface(interfaceNumber, new CallbackPromiseAdapter<void, U SBError>(resolver)); | |
179 return promise; | |
180 } | |
181 | |
182 ScriptPromise USBDevice::releaseInterface(ScriptState* scriptState, uint8_t inte rfaceNumber) | |
183 { | |
184 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver:: create(scriptState); | |
185 ScriptPromise promise = resolver->promise(); | |
186 m_device->releaseInterface(interfaceNumber, new CallbackPromiseAdapter<void, USBError>(resolver)); | |
187 return promise; | |
188 } | |
189 | |
190 ScriptPromise USBDevice::setInterface(ScriptState* scriptState, uint8_t interfac eNumber, uint8_t alternateSetting) | |
191 { | |
192 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver:: create(scriptState); | |
193 ScriptPromise promise = resolver->promise(); | |
194 m_device->setInterface(interfaceNumber, alternateSetting, new CallbackPromis eAdapter<void, USBError>(resolver)); | |
195 return promise; | |
196 } | |
197 | |
198 ScriptPromise USBDevice::controlTransferIn(ScriptState* scriptState, const USBCo ntrolTransferParameters& parameters, uint16_t length) | |
199 { | |
200 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver:: create(scriptState); | |
201 ScriptPromise promise = resolver->promise(); | |
202 WebUSBDevice::ControlTransferParameters webParameters = ConvertControlTransf erParameters(WebUSBDevice::TransferDirectionIn, parameters); | |
203 m_device->controlTransfer(webParameters, nullptr, length, 0, new CallbackPro miseAdapter<InputTransferResult, USBError>(resolver)); | |
204 return promise; | |
205 } | |
206 | |
207 ScriptPromise USBDevice::controlTransferOut(ScriptState* scriptState, const USBC ontrolTransferParameters& parameters) | |
208 { | |
209 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver:: create(scriptState); | |
210 ScriptPromise promise = resolver->promise(); | |
211 WebUSBDevice::ControlTransferParameters webParameters = ConvertControlTransf erParameters(WebUSBDevice::TransferDirectionOut, parameters); | |
212 m_device->controlTransfer(webParameters, nullptr, 0, 0, new CallbackPromiseA dapter<OutputTransferResult, USBError>(resolver)); | |
213 return promise; | |
214 } | |
215 | |
216 | |
217 ScriptPromise USBDevice::controlTransferOut(ScriptState* scriptState, const USBC ontrolTransferParameters& parameters, const ArrayBufferOrArrayBufferView& data) | |
218 { | |
219 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver:: create(scriptState); | |
220 ScriptPromise promise = resolver->promise(); | |
221 WebUSBDevice::ControlTransferParameters webParameters = ConvertControlTransf erParameters(WebUSBDevice::TransferDirectionOut, parameters); | |
222 BufferSource buffer(data); | |
223 m_device->controlTransfer(webParameters, buffer.data(), buffer.size(), 0, ne w CallbackPromiseAdapter<OutputTransferResult, USBError>(resolver)); | |
224 return promise; | |
225 } | |
226 | |
227 ScriptPromise USBDevice::clearHalt(ScriptState* scriptState, uint8_t endpointNum ber) | |
228 { | |
229 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver:: create(scriptState); | |
230 ScriptPromise promise = resolver->promise(); | |
231 m_device->clearHalt(endpointNumber, new CallbackPromiseAdapter<void, USBErro r>(resolver)); | |
232 return promise; | |
233 } | |
234 | |
235 ScriptPromise USBDevice::transferIn(ScriptState* scriptState, uint8_t endpointNu mber, unsigned length) | |
236 { | |
237 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver:: create(scriptState); | |
238 ScriptPromise promise = resolver->promise(); | |
239 m_device->transfer(WebUSBDevice::TransferDirectionIn, endpointNumber, nullpt r, length, 0, new CallbackPromiseAdapter<InputTransferResult, USBError>(resolver )); | |
240 return promise; | |
241 } | |
242 | |
243 ScriptPromise USBDevice::transferOut(ScriptState* scriptState, uint8_t endpointN umber, const ArrayBufferOrArrayBufferView& data) | |
244 { | |
245 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver:: create(scriptState); | |
246 ScriptPromise promise = resolver->promise(); | |
247 BufferSource buffer(data); | |
248 m_device->transfer(WebUSBDevice::TransferDirectionOut, endpointNumber, buffe r.data(), buffer.size(), 0, new CallbackPromiseAdapter<OutputTransferResult, USB Error>(resolver)); | |
249 return promise; | |
250 } | |
251 | |
252 ScriptPromise USBDevice::reset(ScriptState* scriptState) | |
253 { | |
254 RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver:: create(scriptState); | |
255 ScriptPromise promise = resolver->promise(); | |
256 m_device->reset(new CallbackPromiseAdapter<void, USBError>(resolver)); | |
257 return promise; | |
258 } | |
259 | |
260 } // namespace blink | |
OLD | NEW |