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 "device/usb/webusb_descriptors.h" | 5 #include "device/usb/webusb_descriptors.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <iterator> | 9 #include <iterator> |
10 #include <map> | 10 #include <map> |
(...skipping 174 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
185 | 185 |
186 callback.Run(std::move(allowed_origins), landing_page); | 186 callback.Run(std::move(allowed_origins), landing_page); |
187 } | 187 } |
188 | 188 |
189 void OnReadUrlDescriptor(std::map<uint8_t, GURL>* url_map, | 189 void OnReadUrlDescriptor(std::map<uint8_t, GURL>* url_map, |
190 uint8_t index, | 190 uint8_t index, |
191 const base::Closure& callback, | 191 const base::Closure& callback, |
192 UsbTransferStatus status, | 192 UsbTransferStatus status, |
193 scoped_refptr<net::IOBuffer> buffer, | 193 scoped_refptr<net::IOBuffer> buffer, |
194 size_t length) { | 194 size_t length) { |
195 if (status != USB_TRANSFER_COMPLETED) { | 195 if (status != UsbTransferStatus::COMPLETED) { |
196 USB_LOG(EVENT) << "Failed to read WebUSB URL descriptor: " << index; | 196 USB_LOG(EVENT) << "Failed to read WebUSB URL descriptor: " << index; |
197 callback.Run(); | 197 callback.Run(); |
198 return; | 198 return; |
199 } | 199 } |
200 | 200 |
201 GURL url; | 201 GURL url; |
202 if (ParseWebUsbUrlDescriptor( | 202 if (ParseWebUsbUrlDescriptor( |
203 std::vector<uint8_t>(buffer->data(), buffer->data() + length), | 203 std::vector<uint8_t>(buffer->data(), buffer->data() + length), |
204 &url)) { | 204 &url)) { |
205 (*url_map)[index] = url; | 205 (*url_map)[index] = url; |
206 } | 206 } |
207 callback.Run(); | 207 callback.Run(); |
208 } | 208 } |
209 | 209 |
210 // Reads the descriptor with |index| from the device, adds the value to | 210 // Reads the descriptor with |index| from the device, adds the value to |
211 // |url_map| and then runs |callback|. | 211 // |url_map| and then runs |callback|. |
212 void ReadUrlDescriptor(scoped_refptr<UsbDeviceHandle> device_handle, | 212 void ReadUrlDescriptor(scoped_refptr<UsbDeviceHandle> device_handle, |
213 uint8_t vendor_code, | 213 uint8_t vendor_code, |
214 std::map<uint8_t, GURL>* url_map, | 214 std::map<uint8_t, GURL>* url_map, |
215 uint8_t index, | 215 uint8_t index, |
216 const base::Closure& callback) { | 216 const base::Closure& callback) { |
217 scoped_refptr<IOBufferWithSize> buffer = new IOBufferWithSize(255); | 217 scoped_refptr<IOBufferWithSize> buffer = new IOBufferWithSize(255); |
218 device_handle->ControlTransfer( | 218 device_handle->ControlTransfer( |
219 USB_DIRECTION_INBOUND, UsbDeviceHandle::VENDOR, UsbDeviceHandle::DEVICE, | 219 UsbTransferDirection::INBOUND, UsbControlTransferType::VENDOR, |
220 vendor_code, index, kGetUrlRequest, buffer, buffer->size(), | 220 UsbControlTransferRecipient::DEVICE, vendor_code, index, kGetUrlRequest, |
221 kControlTransferTimeout, | 221 buffer, buffer->size(), kControlTransferTimeout, |
222 base::Bind(&OnReadUrlDescriptor, url_map, index, callback)); | 222 base::Bind(&OnReadUrlDescriptor, url_map, index, callback)); |
223 } | 223 } |
224 | 224 |
225 // Reads URL descriptors from the device so that it can fill |allowed_origins| | 225 // Reads URL descriptors from the device so that it can fill |allowed_origins| |
226 // with the GURLs matching the indicies already collected. | 226 // with the GURLs matching the indicies already collected. |
227 void ReadUrlDescriptors(scoped_refptr<UsbDeviceHandle> device_handle, | 227 void ReadUrlDescriptors(scoped_refptr<UsbDeviceHandle> device_handle, |
228 uint8_t vendor_code, | 228 uint8_t vendor_code, |
229 uint8_t landing_page_id, | 229 uint8_t landing_page_id, |
230 const ReadWebUsbDescriptorsCallback& callback, | 230 const ReadWebUsbDescriptorsCallback& callback, |
231 std::unique_ptr<WebUsbAllowedOrigins> allowed_origins) { | 231 std::unique_ptr<WebUsbAllowedOrigins> allowed_origins) { |
(...skipping 26 matching lines...) Expand all Loading... |
258 for (uint8_t index : to_request) { | 258 for (uint8_t index : to_request) { |
259 ReadUrlDescriptor(device_handle, vendor_code, url_map_ptr, index, barrier); | 259 ReadUrlDescriptor(device_handle, vendor_code, url_map_ptr, index, barrier); |
260 } | 260 } |
261 } | 261 } |
262 | 262 |
263 void OnReadWebUsbAllowedOrigins( | 263 void OnReadWebUsbAllowedOrigins( |
264 const ReadWebUsbAllowedOriginsCallback& callback, | 264 const ReadWebUsbAllowedOriginsCallback& callback, |
265 UsbTransferStatus status, | 265 UsbTransferStatus status, |
266 scoped_refptr<net::IOBuffer> buffer, | 266 scoped_refptr<net::IOBuffer> buffer, |
267 size_t length) { | 267 size_t length) { |
268 if (status != USB_TRANSFER_COMPLETED) { | 268 if (status != UsbTransferStatus::COMPLETED) { |
269 USB_LOG(EVENT) << "Failed to read WebUSB allowed origins."; | 269 USB_LOG(EVENT) << "Failed to read WebUSB allowed origins."; |
270 callback.Run(nullptr); | 270 callback.Run(nullptr); |
271 return; | 271 return; |
272 } | 272 } |
273 | 273 |
274 std::unique_ptr<WebUsbAllowedOrigins> allowed_origins( | 274 std::unique_ptr<WebUsbAllowedOrigins> allowed_origins( |
275 new WebUsbAllowedOrigins()); | 275 new WebUsbAllowedOrigins()); |
276 if (allowed_origins->Parse( | 276 if (allowed_origins->Parse( |
277 std::vector<uint8_t>(buffer->data(), buffer->data() + length))) { | 277 std::vector<uint8_t>(buffer->data(), buffer->data() + length))) { |
278 callback.Run(std::move(allowed_origins)); | 278 callback.Run(std::move(allowed_origins)); |
279 } else { | 279 } else { |
280 callback.Run(nullptr); | 280 callback.Run(nullptr); |
281 } | 281 } |
282 } | 282 } |
283 | 283 |
284 void OnReadWebUsbAllowedOriginsHeader( | 284 void OnReadWebUsbAllowedOriginsHeader( |
285 scoped_refptr<UsbDeviceHandle> device_handle, | 285 scoped_refptr<UsbDeviceHandle> device_handle, |
286 const ReadWebUsbAllowedOriginsCallback& callback, | 286 const ReadWebUsbAllowedOriginsCallback& callback, |
287 uint8_t vendor_code, | 287 uint8_t vendor_code, |
288 UsbTransferStatus status, | 288 UsbTransferStatus status, |
289 scoped_refptr<net::IOBuffer> buffer, | 289 scoped_refptr<net::IOBuffer> buffer, |
290 size_t length) { | 290 size_t length) { |
291 if (status != USB_TRANSFER_COMPLETED || length != 4) { | 291 if (status != UsbTransferStatus::COMPLETED || length != 4) { |
292 USB_LOG(EVENT) << "Failed to read WebUSB allowed origins header."; | 292 USB_LOG(EVENT) << "Failed to read WebUSB allowed origins header."; |
293 callback.Run(nullptr); | 293 callback.Run(nullptr); |
294 return; | 294 return; |
295 } | 295 } |
296 | 296 |
297 const uint8_t* data = reinterpret_cast<uint8_t*>(buffer->data()); | 297 const uint8_t* data = reinterpret_cast<uint8_t*>(buffer->data()); |
298 uint16_t new_length = data[2] | (data[3] << 8); | 298 uint16_t new_length = data[2] | (data[3] << 8); |
299 scoped_refptr<IOBufferWithSize> new_buffer = new IOBufferWithSize(new_length); | 299 scoped_refptr<IOBufferWithSize> new_buffer = new IOBufferWithSize(new_length); |
300 device_handle->ControlTransfer( | 300 device_handle->ControlTransfer( |
301 USB_DIRECTION_INBOUND, UsbDeviceHandle::VENDOR, UsbDeviceHandle::DEVICE, | 301 UsbTransferDirection::INBOUND, UsbControlTransferType::VENDOR, |
302 vendor_code, 0, kGetAllowedOriginsRequest, new_buffer, new_buffer->size(), | 302 UsbControlTransferRecipient::DEVICE, vendor_code, 0, |
| 303 kGetAllowedOriginsRequest, new_buffer, new_buffer->size(), |
303 kControlTransferTimeout, | 304 kControlTransferTimeout, |
304 base::Bind(&OnReadWebUsbAllowedOrigins, callback)); | 305 base::Bind(&OnReadWebUsbAllowedOrigins, callback)); |
305 } | 306 } |
306 | 307 |
307 void ReadWebUsbAllowedOrigins( | 308 void ReadWebUsbAllowedOrigins( |
308 scoped_refptr<UsbDeviceHandle> device_handle, | 309 scoped_refptr<UsbDeviceHandle> device_handle, |
309 uint8_t vendor_code, | 310 uint8_t vendor_code, |
310 const ReadWebUsbAllowedOriginsCallback& callback) { | 311 const ReadWebUsbAllowedOriginsCallback& callback) { |
311 scoped_refptr<IOBufferWithSize> buffer = new IOBufferWithSize(4); | 312 scoped_refptr<IOBufferWithSize> buffer = new IOBufferWithSize(4); |
312 device_handle->ControlTransfer( | 313 device_handle->ControlTransfer( |
313 USB_DIRECTION_INBOUND, UsbDeviceHandle::VENDOR, UsbDeviceHandle::DEVICE, | 314 UsbTransferDirection::INBOUND, UsbControlTransferType::VENDOR, |
314 vendor_code, 0, kGetAllowedOriginsRequest, buffer, buffer->size(), | 315 UsbControlTransferRecipient::DEVICE, vendor_code, 0, |
| 316 kGetAllowedOriginsRequest, buffer, buffer->size(), |
315 kControlTransferTimeout, | 317 kControlTransferTimeout, |
316 base::Bind(&OnReadWebUsbAllowedOriginsHeader, device_handle, callback, | 318 base::Bind(&OnReadWebUsbAllowedOriginsHeader, device_handle, callback, |
317 vendor_code)); | 319 vendor_code)); |
318 } | 320 } |
319 | 321 |
320 void OnReadBosDescriptor(scoped_refptr<UsbDeviceHandle> device_handle, | 322 void OnReadBosDescriptor(scoped_refptr<UsbDeviceHandle> device_handle, |
321 const ReadWebUsbDescriptorsCallback& callback, | 323 const ReadWebUsbDescriptorsCallback& callback, |
322 UsbTransferStatus status, | 324 UsbTransferStatus status, |
323 scoped_refptr<net::IOBuffer> buffer, | 325 scoped_refptr<net::IOBuffer> buffer, |
324 size_t length) { | 326 size_t length) { |
325 if (status != USB_TRANSFER_COMPLETED) { | 327 if (status != UsbTransferStatus::COMPLETED) { |
326 USB_LOG(EVENT) << "Failed to read BOS descriptor."; | 328 USB_LOG(EVENT) << "Failed to read BOS descriptor."; |
327 callback.Run(nullptr, GURL()); | 329 callback.Run(nullptr, GURL()); |
328 return; | 330 return; |
329 } | 331 } |
330 | 332 |
331 WebUsbPlatformCapabilityDescriptor descriptor; | 333 WebUsbPlatformCapabilityDescriptor descriptor; |
332 if (!descriptor.ParseFromBosDescriptor( | 334 if (!descriptor.ParseFromBosDescriptor( |
333 std::vector<uint8_t>(buffer->data(), buffer->data() + length))) { | 335 std::vector<uint8_t>(buffer->data(), buffer->data() + length))) { |
334 callback.Run(nullptr, GURL()); | 336 callback.Run(nullptr, GURL()); |
335 return; | 337 return; |
336 } | 338 } |
337 | 339 |
338 ReadWebUsbAllowedOrigins( | 340 ReadWebUsbAllowedOrigins( |
339 device_handle, descriptor.vendor_code, | 341 device_handle, descriptor.vendor_code, |
340 base::Bind(&ReadUrlDescriptors, device_handle, descriptor.vendor_code, | 342 base::Bind(&ReadUrlDescriptors, device_handle, descriptor.vendor_code, |
341 descriptor.landing_page_id, callback)); | 343 descriptor.landing_page_id, callback)); |
342 } | 344 } |
343 | 345 |
344 void OnReadBosDescriptorHeader(scoped_refptr<UsbDeviceHandle> device_handle, | 346 void OnReadBosDescriptorHeader(scoped_refptr<UsbDeviceHandle> device_handle, |
345 const ReadWebUsbDescriptorsCallback& callback, | 347 const ReadWebUsbDescriptorsCallback& callback, |
346 UsbTransferStatus status, | 348 UsbTransferStatus status, |
347 scoped_refptr<net::IOBuffer> buffer, | 349 scoped_refptr<net::IOBuffer> buffer, |
348 size_t length) { | 350 size_t length) { |
349 if (status != USB_TRANSFER_COMPLETED || length != 5) { | 351 if (status != UsbTransferStatus::COMPLETED || length != 5) { |
350 USB_LOG(EVENT) << "Failed to read BOS descriptor header."; | 352 USB_LOG(EVENT) << "Failed to read BOS descriptor header."; |
351 callback.Run(nullptr, GURL()); | 353 callback.Run(nullptr, GURL()); |
352 return; | 354 return; |
353 } | 355 } |
354 | 356 |
355 const uint8_t* data = reinterpret_cast<uint8_t*>(buffer->data()); | 357 const uint8_t* data = reinterpret_cast<uint8_t*>(buffer->data()); |
356 uint16_t new_length = data[2] | (data[3] << 8); | 358 uint16_t new_length = data[2] | (data[3] << 8); |
357 scoped_refptr<IOBufferWithSize> new_buffer = new IOBufferWithSize(new_length); | 359 scoped_refptr<IOBufferWithSize> new_buffer = new IOBufferWithSize(new_length); |
358 device_handle->ControlTransfer( | 360 device_handle->ControlTransfer( |
359 USB_DIRECTION_INBOUND, UsbDeviceHandle::STANDARD, UsbDeviceHandle::DEVICE, | 361 UsbTransferDirection::INBOUND, UsbControlTransferType::STANDARD, |
360 kGetDescriptorRequest, kBosDescriptorType << 8, 0, new_buffer, | 362 UsbControlTransferRecipient::DEVICE, kGetDescriptorRequest, |
361 new_buffer->size(), kControlTransferTimeout, | 363 kBosDescriptorType << 8, 0, new_buffer, new_buffer->size(), |
| 364 kControlTransferTimeout, |
362 base::Bind(&OnReadBosDescriptor, device_handle, callback)); | 365 base::Bind(&OnReadBosDescriptor, device_handle, callback)); |
363 } | 366 } |
364 | 367 |
365 } // namespace | 368 } // namespace |
366 | 369 |
367 WebUsbFunctionSubset::WebUsbFunctionSubset() : first_interface(0) {} | 370 WebUsbFunctionSubset::WebUsbFunctionSubset() : first_interface(0) {} |
368 | 371 |
369 WebUsbFunctionSubset::WebUsbFunctionSubset(const WebUsbFunctionSubset& other) = | 372 WebUsbFunctionSubset::WebUsbFunctionSubset(const WebUsbFunctionSubset& other) = |
370 default; | 373 default; |
371 | 374 |
(...skipping 189 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
561 return false; | 564 return false; |
562 } | 565 } |
563 | 566 |
564 return true; | 567 return true; |
565 } | 568 } |
566 | 569 |
567 void ReadWebUsbDescriptors(scoped_refptr<UsbDeviceHandle> device_handle, | 570 void ReadWebUsbDescriptors(scoped_refptr<UsbDeviceHandle> device_handle, |
568 const ReadWebUsbDescriptorsCallback& callback) { | 571 const ReadWebUsbDescriptorsCallback& callback) { |
569 scoped_refptr<IOBufferWithSize> buffer = new IOBufferWithSize(5); | 572 scoped_refptr<IOBufferWithSize> buffer = new IOBufferWithSize(5); |
570 device_handle->ControlTransfer( | 573 device_handle->ControlTransfer( |
571 USB_DIRECTION_INBOUND, UsbDeviceHandle::STANDARD, UsbDeviceHandle::DEVICE, | 574 UsbTransferDirection::INBOUND, UsbControlTransferType::STANDARD, |
572 kGetDescriptorRequest, kBosDescriptorType << 8, 0, buffer, buffer->size(), | 575 UsbControlTransferRecipient::DEVICE, kGetDescriptorRequest, |
| 576 kBosDescriptorType << 8, 0, buffer, buffer->size(), |
573 kControlTransferTimeout, | 577 kControlTransferTimeout, |
574 base::Bind(&OnReadBosDescriptorHeader, device_handle, callback)); | 578 base::Bind(&OnReadBosDescriptorHeader, device_handle, callback)); |
575 } | 579 } |
576 | 580 |
577 bool FindInWebUsbAllowedOrigins( | 581 bool FindInWebUsbAllowedOrigins( |
578 const device::WebUsbAllowedOrigins* allowed_origins, | 582 const device::WebUsbAllowedOrigins* allowed_origins, |
579 const GURL& origin, | 583 const GURL& origin, |
580 base::Optional<uint8_t> config_value, | 584 base::Optional<uint8_t> config_value, |
581 base::Optional<uint8_t> first_interface) { | 585 base::Optional<uint8_t> first_interface) { |
582 if (!allowed_origins) | 586 if (!allowed_origins) |
(...skipping 15 matching lines...) Expand all Loading... |
598 | 602 |
599 if (base::ContainsValue(function.origins, origin)) | 603 if (base::ContainsValue(function.origins, origin)) |
600 return true; | 604 return true; |
601 } | 605 } |
602 } | 606 } |
603 | 607 |
604 return false; | 608 return false; |
605 } | 609 } |
606 | 610 |
607 } // namespace device | 611 } // namespace device |
OLD | NEW |