OLD | NEW |
---|---|
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 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/usb_device_handle_impl.h" | 5 #include "device/usb/usb_device_handle_impl.h" |
6 | 6 |
7 #include <algorithm> | 7 #include <algorithm> |
8 #include <memory> | 8 #include <memory> |
9 #include <numeric> | 9 #include <numeric> |
10 #include <utility> | 10 #include <utility> |
(...skipping 17 matching lines...) Expand all Loading... | |
28 #include "third_party/libusb/src/libusb/libusb.h" | 28 #include "third_party/libusb/src/libusb/libusb.h" |
29 | 29 |
30 namespace device { | 30 namespace device { |
31 | 31 |
32 typedef libusb_device* PlatformUsbDevice; | 32 typedef libusb_device* PlatformUsbDevice; |
33 | 33 |
34 void HandleTransferCompletion(PlatformUsbTransferHandle transfer); | 34 void HandleTransferCompletion(PlatformUsbTransferHandle transfer); |
35 | 35 |
36 namespace { | 36 namespace { |
37 | 37 |
38 uint8_t ConvertTransferDirection(UsbEndpointDirection direction) { | 38 uint8_t ConvertTransferDirection(UsbTransferDirection direction) { |
39 switch (direction) { | 39 switch (direction) { |
40 case USB_DIRECTION_INBOUND: | 40 case UsbTransferDirection::INBOUND: |
41 return LIBUSB_ENDPOINT_IN; | 41 return LIBUSB_ENDPOINT_IN; |
42 case USB_DIRECTION_OUTBOUND: | 42 case UsbTransferDirection::OUTBOUND: |
43 return LIBUSB_ENDPOINT_OUT; | 43 return LIBUSB_ENDPOINT_OUT; |
44 default: | 44 default: |
45 NOTREACHED(); | 45 NOTREACHED(); |
46 return LIBUSB_ENDPOINT_IN; | 46 return LIBUSB_ENDPOINT_IN; |
47 } | 47 } |
48 } | 48 } |
49 | 49 |
50 uint8_t CreateRequestType(UsbEndpointDirection direction, | 50 uint8_t CreateRequestType(UsbTransferDirection direction, |
51 UsbDeviceHandle::TransferRequestType request_type, | 51 UsbControlTransferType request_type, |
52 UsbDeviceHandle::TransferRecipient recipient) { | 52 UsbControlTransferRecipient recipient) { |
53 uint8_t result = ConvertTransferDirection(direction); | 53 uint8_t result = ConvertTransferDirection(direction); |
54 | 54 |
55 switch (request_type) { | 55 switch (request_type) { |
56 case UsbDeviceHandle::STANDARD: | 56 case UsbControlTransferType::STANDARD: |
57 result |= LIBUSB_REQUEST_TYPE_STANDARD; | 57 result |= LIBUSB_REQUEST_TYPE_STANDARD; |
58 break; | 58 break; |
59 case UsbDeviceHandle::CLASS: | 59 case UsbControlTransferType::CLASS: |
60 result |= LIBUSB_REQUEST_TYPE_CLASS; | 60 result |= LIBUSB_REQUEST_TYPE_CLASS; |
61 break; | 61 break; |
62 case UsbDeviceHandle::VENDOR: | 62 case UsbControlTransferType::VENDOR: |
63 result |= LIBUSB_REQUEST_TYPE_VENDOR; | 63 result |= LIBUSB_REQUEST_TYPE_VENDOR; |
64 break; | 64 break; |
65 case UsbDeviceHandle::RESERVED: | 65 case UsbControlTransferType::RESERVED: |
66 result |= LIBUSB_REQUEST_TYPE_RESERVED; | 66 result |= LIBUSB_REQUEST_TYPE_RESERVED; |
67 break; | 67 break; |
68 } | 68 } |
69 | 69 |
70 switch (recipient) { | 70 switch (recipient) { |
71 case UsbDeviceHandle::DEVICE: | 71 case UsbControlTransferRecipient::DEVICE: |
72 result |= LIBUSB_RECIPIENT_DEVICE; | 72 result |= LIBUSB_RECIPIENT_DEVICE; |
73 break; | 73 break; |
74 case UsbDeviceHandle::INTERFACE: | 74 case UsbControlTransferRecipient::INTERFACE: |
75 result |= LIBUSB_RECIPIENT_INTERFACE; | 75 result |= LIBUSB_RECIPIENT_INTERFACE; |
76 break; | 76 break; |
77 case UsbDeviceHandle::ENDPOINT: | 77 case UsbControlTransferRecipient::ENDPOINT: |
78 result |= LIBUSB_RECIPIENT_ENDPOINT; | 78 result |= LIBUSB_RECIPIENT_ENDPOINT; |
79 break; | 79 break; |
80 case UsbDeviceHandle::OTHER: | 80 case UsbControlTransferRecipient::OTHER: |
81 result |= LIBUSB_RECIPIENT_OTHER; | 81 result |= LIBUSB_RECIPIENT_OTHER; |
82 break; | 82 break; |
83 } | 83 } |
84 | 84 |
85 return result; | 85 return result; |
86 } | 86 } |
87 | 87 |
88 static UsbTransferStatus ConvertTransferStatus( | 88 static UsbTransferStatus ConvertTransferStatus( |
89 const libusb_transfer_status status) { | 89 const libusb_transfer_status status) { |
90 switch (status) { | 90 switch (status) { |
91 case LIBUSB_TRANSFER_COMPLETED: | 91 case LIBUSB_TRANSFER_COMPLETED: |
92 return USB_TRANSFER_COMPLETED; | 92 return UsbTransferStatus::COMPLETED; |
93 case LIBUSB_TRANSFER_ERROR: | 93 case LIBUSB_TRANSFER_ERROR: |
94 return USB_TRANSFER_ERROR; | 94 return UsbTransferStatus::TRANSFER_ERROR; |
95 case LIBUSB_TRANSFER_TIMED_OUT: | 95 case LIBUSB_TRANSFER_TIMED_OUT: |
96 return USB_TRANSFER_TIMEOUT; | 96 return UsbTransferStatus::TIMEOUT; |
97 case LIBUSB_TRANSFER_STALL: | 97 case LIBUSB_TRANSFER_STALL: |
98 return USB_TRANSFER_STALLED; | 98 return UsbTransferStatus::STALLED; |
99 case LIBUSB_TRANSFER_NO_DEVICE: | 99 case LIBUSB_TRANSFER_NO_DEVICE: |
100 return USB_TRANSFER_DISCONNECT; | 100 return UsbTransferStatus::DISCONNECT; |
101 case LIBUSB_TRANSFER_OVERFLOW: | 101 case LIBUSB_TRANSFER_OVERFLOW: |
102 return USB_TRANSFER_OVERFLOW; | 102 return UsbTransferStatus::BABBLE; |
103 case LIBUSB_TRANSFER_CANCELLED: | 103 case LIBUSB_TRANSFER_CANCELLED: |
104 return USB_TRANSFER_CANCELLED; | 104 return UsbTransferStatus::CANCELLED; |
105 default: | 105 default: |
mcasas
2017/04/17 17:15:15
Nit: no need for default: since we cover all
libu
Reilly Grant (use Gerrit)
2017/04/17 19:20:48
Done.
| |
106 NOTREACHED(); | 106 NOTREACHED(); |
107 return USB_TRANSFER_ERROR; | 107 return UsbTransferStatus::TRANSFER_ERROR; |
108 } | 108 } |
109 } | 109 } |
110 | 110 |
111 static void RunTransferCallback( | 111 static void RunTransferCallback( |
112 scoped_refptr<base::TaskRunner> callback_task_runner, | 112 scoped_refptr<base::TaskRunner> callback_task_runner, |
113 const UsbDeviceHandle::TransferCallback& callback, | 113 const UsbDeviceHandle::TransferCallback& callback, |
114 UsbTransferStatus status, | 114 UsbTransferStatus status, |
115 scoped_refptr<net::IOBuffer> buffer, | 115 scoped_refptr<net::IOBuffer> buffer, |
116 size_t result) { | 116 size_t result) { |
117 if (callback_task_runner->RunsTasksOnCurrentThread()) { | 117 if (callback_task_runner->RunsTasksOnCurrentThread()) { |
(...skipping 173 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
291 uint8_t type, | 291 uint8_t type, |
292 uint8_t request, | 292 uint8_t request, |
293 uint16_t value, | 293 uint16_t value, |
294 uint16_t index, | 294 uint16_t index, |
295 uint16_t length, | 295 uint16_t length, |
296 scoped_refptr<net::IOBuffer> buffer, | 296 scoped_refptr<net::IOBuffer> buffer, |
297 unsigned int timeout, | 297 unsigned int timeout, |
298 scoped_refptr<base::TaskRunner> callback_task_runner, | 298 scoped_refptr<base::TaskRunner> callback_task_runner, |
299 const TransferCallback& callback) { | 299 const TransferCallback& callback) { |
300 std::unique_ptr<Transfer> transfer(new Transfer( | 300 std::unique_ptr<Transfer> transfer(new Transfer( |
301 device_handle, nullptr, USB_TRANSFER_CONTROL, buffer, | 301 device_handle, nullptr, UsbTransferType::CONTROL, buffer, |
302 length + LIBUSB_CONTROL_SETUP_SIZE, callback_task_runner, callback)); | 302 length + LIBUSB_CONTROL_SETUP_SIZE, callback_task_runner, callback)); |
303 | 303 |
304 transfer->platform_transfer_ = libusb_alloc_transfer(0); | 304 transfer->platform_transfer_ = libusb_alloc_transfer(0); |
305 if (!transfer->platform_transfer_) { | 305 if (!transfer->platform_transfer_) { |
306 USB_LOG(ERROR) << "Failed to allocate control transfer."; | 306 USB_LOG(ERROR) << "Failed to allocate control transfer."; |
307 return nullptr; | 307 return nullptr; |
308 } | 308 } |
309 | 309 |
310 libusb_fill_control_setup(reinterpret_cast<uint8_t*>(buffer->data()), type, | 310 libusb_fill_control_setup(reinterpret_cast<uint8_t*>(buffer->data()), type, |
311 request, value, index, length); | 311 request, value, index, length); |
(...skipping 11 matching lines...) Expand all Loading... | |
323 UsbDeviceHandleImpl::Transfer::CreateBulkTransfer( | 323 UsbDeviceHandleImpl::Transfer::CreateBulkTransfer( |
324 scoped_refptr<UsbDeviceHandleImpl> device_handle, | 324 scoped_refptr<UsbDeviceHandleImpl> device_handle, |
325 uint8_t endpoint, | 325 uint8_t endpoint, |
326 scoped_refptr<net::IOBuffer> buffer, | 326 scoped_refptr<net::IOBuffer> buffer, |
327 int length, | 327 int length, |
328 unsigned int timeout, | 328 unsigned int timeout, |
329 scoped_refptr<base::TaskRunner> callback_task_runner, | 329 scoped_refptr<base::TaskRunner> callback_task_runner, |
330 const TransferCallback& callback) { | 330 const TransferCallback& callback) { |
331 std::unique_ptr<Transfer> transfer(new Transfer( | 331 std::unique_ptr<Transfer> transfer(new Transfer( |
332 device_handle, device_handle->GetClaimedInterfaceForEndpoint(endpoint), | 332 device_handle, device_handle->GetClaimedInterfaceForEndpoint(endpoint), |
333 USB_TRANSFER_BULK, buffer, length, callback_task_runner, callback)); | 333 UsbTransferType::BULK, buffer, length, callback_task_runner, callback)); |
334 | 334 |
335 transfer->platform_transfer_ = libusb_alloc_transfer(0); | 335 transfer->platform_transfer_ = libusb_alloc_transfer(0); |
336 if (!transfer->platform_transfer_) { | 336 if (!transfer->platform_transfer_) { |
337 USB_LOG(ERROR) << "Failed to allocate bulk transfer."; | 337 USB_LOG(ERROR) << "Failed to allocate bulk transfer."; |
338 return nullptr; | 338 return nullptr; |
339 } | 339 } |
340 | 340 |
341 libusb_fill_bulk_transfer(transfer->platform_transfer_, | 341 libusb_fill_bulk_transfer(transfer->platform_transfer_, |
342 device_handle->handle_, endpoint, | 342 device_handle->handle_, endpoint, |
343 reinterpret_cast<uint8_t*>(buffer->data()), length, | 343 reinterpret_cast<uint8_t*>(buffer->data()), length, |
344 &UsbDeviceHandleImpl::Transfer::PlatformCallback, | 344 &UsbDeviceHandleImpl::Transfer::PlatformCallback, |
345 transfer.get(), timeout); | 345 transfer.get(), timeout); |
346 | 346 |
347 return transfer; | 347 return transfer; |
348 } | 348 } |
349 | 349 |
350 // static | 350 // static |
351 std::unique_ptr<UsbDeviceHandleImpl::Transfer> | 351 std::unique_ptr<UsbDeviceHandleImpl::Transfer> |
352 UsbDeviceHandleImpl::Transfer::CreateInterruptTransfer( | 352 UsbDeviceHandleImpl::Transfer::CreateInterruptTransfer( |
353 scoped_refptr<UsbDeviceHandleImpl> device_handle, | 353 scoped_refptr<UsbDeviceHandleImpl> device_handle, |
354 uint8_t endpoint, | 354 uint8_t endpoint, |
355 scoped_refptr<net::IOBuffer> buffer, | 355 scoped_refptr<net::IOBuffer> buffer, |
356 int length, | 356 int length, |
357 unsigned int timeout, | 357 unsigned int timeout, |
358 scoped_refptr<base::TaskRunner> callback_task_runner, | 358 scoped_refptr<base::TaskRunner> callback_task_runner, |
359 const TransferCallback& callback) { | 359 const TransferCallback& callback) { |
360 std::unique_ptr<Transfer> transfer(new Transfer( | 360 std::unique_ptr<Transfer> transfer(new Transfer( |
361 device_handle, device_handle->GetClaimedInterfaceForEndpoint(endpoint), | 361 device_handle, device_handle->GetClaimedInterfaceForEndpoint(endpoint), |
362 USB_TRANSFER_INTERRUPT, buffer, length, callback_task_runner, callback)); | 362 UsbTransferType::INTERRUPT, buffer, length, callback_task_runner, |
363 callback)); | |
363 | 364 |
364 transfer->platform_transfer_ = libusb_alloc_transfer(0); | 365 transfer->platform_transfer_ = libusb_alloc_transfer(0); |
365 if (!transfer->platform_transfer_) { | 366 if (!transfer->platform_transfer_) { |
366 USB_LOG(ERROR) << "Failed to allocate interrupt transfer."; | 367 USB_LOG(ERROR) << "Failed to allocate interrupt transfer."; |
367 return nullptr; | 368 return nullptr; |
368 } | 369 } |
369 | 370 |
370 libusb_fill_interrupt_transfer( | 371 libusb_fill_interrupt_transfer( |
371 transfer->platform_transfer_, device_handle->handle_, endpoint, | 372 transfer->platform_transfer_, device_handle->handle_, endpoint, |
372 reinterpret_cast<uint8_t*>(buffer->data()), length, | 373 reinterpret_cast<uint8_t*>(buffer->data()), length, |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
426 callback_(callback) { | 427 callback_(callback) { |
427 task_runner_ = base::ThreadTaskRunnerHandle::Get(); | 428 task_runner_ = base::ThreadTaskRunnerHandle::Get(); |
428 } | 429 } |
429 | 430 |
430 UsbDeviceHandleImpl::Transfer::Transfer( | 431 UsbDeviceHandleImpl::Transfer::Transfer( |
431 scoped_refptr<UsbDeviceHandleImpl> device_handle, | 432 scoped_refptr<UsbDeviceHandleImpl> device_handle, |
432 scoped_refptr<InterfaceClaimer> claimed_interface, | 433 scoped_refptr<InterfaceClaimer> claimed_interface, |
433 scoped_refptr<net::IOBuffer> buffer, | 434 scoped_refptr<net::IOBuffer> buffer, |
434 scoped_refptr<base::TaskRunner> callback_task_runner, | 435 scoped_refptr<base::TaskRunner> callback_task_runner, |
435 const IsochronousTransferCallback& callback) | 436 const IsochronousTransferCallback& callback) |
436 : transfer_type_(USB_TRANSFER_ISOCHRONOUS), | 437 : transfer_type_(UsbTransferType::ISOCHRONOUS), |
437 device_handle_(device_handle), | 438 device_handle_(device_handle), |
438 buffer_(buffer), | 439 buffer_(buffer), |
439 claimed_interface_(claimed_interface), | 440 claimed_interface_(claimed_interface), |
440 callback_task_runner_(callback_task_runner), | 441 callback_task_runner_(callback_task_runner), |
441 iso_callback_(callback) { | 442 iso_callback_(callback) { |
442 task_runner_ = base::ThreadTaskRunnerHandle::Get(); | 443 task_runner_ = base::ThreadTaskRunnerHandle::Get(); |
443 } | 444 } |
444 | 445 |
445 UsbDeviceHandleImpl::Transfer::~Transfer() { | 446 UsbDeviceHandleImpl::Transfer::~Transfer() { |
446 if (platform_transfer_) { | 447 if (platform_transfer_) { |
447 libusb_free_transfer(platform_transfer_); | 448 libusb_free_transfer(platform_transfer_); |
448 } | 449 } |
449 } | 450 } |
450 | 451 |
451 void UsbDeviceHandleImpl::Transfer::Submit() { | 452 void UsbDeviceHandleImpl::Transfer::Submit() { |
452 const int rv = libusb_submit_transfer(platform_transfer_); | 453 const int rv = libusb_submit_transfer(platform_transfer_); |
453 if (rv != LIBUSB_SUCCESS) { | 454 if (rv != LIBUSB_SUCCESS) { |
454 USB_LOG(EVENT) << "Failed to submit transfer: " | 455 USB_LOG(EVENT) << "Failed to submit transfer: " |
455 << ConvertPlatformUsbErrorToString(rv); | 456 << ConvertPlatformUsbErrorToString(rv); |
456 TransferComplete(USB_TRANSFER_ERROR, 0); | 457 TransferComplete(UsbTransferStatus::TRANSFER_ERROR, 0); |
457 } | 458 } |
458 } | 459 } |
459 | 460 |
460 void UsbDeviceHandleImpl::Transfer::Cancel() { | 461 void UsbDeviceHandleImpl::Transfer::Cancel() { |
461 if (!cancelled_) { | 462 if (!cancelled_) { |
462 libusb_cancel_transfer(platform_transfer_); | 463 libusb_cancel_transfer(platform_transfer_); |
463 claimed_interface_ = nullptr; | 464 claimed_interface_ = nullptr; |
464 } | 465 } |
465 cancelled_ = true; | 466 cancelled_ = true; |
466 } | 467 } |
467 | 468 |
468 void UsbDeviceHandleImpl::Transfer::ProcessCompletion() { | 469 void UsbDeviceHandleImpl::Transfer::ProcessCompletion() { |
469 DCHECK_GE(platform_transfer_->actual_length, 0) | 470 DCHECK_GE(platform_transfer_->actual_length, 0) |
470 << "Negative actual length received"; | 471 << "Negative actual length received"; |
471 size_t actual_length = | 472 size_t actual_length = |
472 static_cast<size_t>(std::max(platform_transfer_->actual_length, 0)); | 473 static_cast<size_t>(std::max(platform_transfer_->actual_length, 0)); |
473 | 474 |
474 DCHECK(length_ >= actual_length) | 475 DCHECK(length_ >= actual_length) |
475 << "data too big for our buffer (libusb failure?)"; | 476 << "data too big for our buffer (libusb failure?)"; |
476 | 477 |
477 switch (transfer_type_) { | 478 switch (transfer_type_) { |
478 case USB_TRANSFER_CONTROL: | 479 case UsbTransferType::CONTROL: |
479 // If the transfer is a control transfer we do not expose the control | 480 // If the transfer is a control transfer we do not expose the control |
480 // setup header to the caller. This logic strips off the header if | 481 // setup header to the caller. This logic strips off the header if |
481 // present before invoking the callback provided with the transfer. | 482 // present before invoking the callback provided with the transfer. |
482 if (actual_length > 0) { | 483 if (actual_length > 0) { |
483 CHECK(length_ >= LIBUSB_CONTROL_SETUP_SIZE) | 484 CHECK(length_ >= LIBUSB_CONTROL_SETUP_SIZE) |
484 << "buffer was not correctly set: too small for the control header"; | 485 << "buffer was not correctly set: too small for the control header"; |
485 | 486 |
486 if (length_ >= (LIBUSB_CONTROL_SETUP_SIZE + actual_length)) { | 487 if (length_ >= (LIBUSB_CONTROL_SETUP_SIZE + actual_length)) { |
487 // If the payload is zero bytes long, pad out the allocated buffer | 488 // If the payload is zero bytes long, pad out the allocated buffer |
488 // size to one byte so that an IOBuffer of that size can be allocated. | 489 // size to one byte so that an IOBuffer of that size can be allocated. |
489 scoped_refptr<net::IOBuffer> resized_buffer = new net::IOBuffer( | 490 scoped_refptr<net::IOBuffer> resized_buffer = new net::IOBuffer( |
490 std::max(actual_length, static_cast<size_t>(1))); | 491 std::max(actual_length, static_cast<size_t>(1))); |
491 memcpy(resized_buffer->data(), | 492 memcpy(resized_buffer->data(), |
492 buffer_->data() + LIBUSB_CONTROL_SETUP_SIZE, actual_length); | 493 buffer_->data() + LIBUSB_CONTROL_SETUP_SIZE, actual_length); |
493 buffer_ = resized_buffer; | 494 buffer_ = resized_buffer; |
494 } | 495 } |
495 } | 496 } |
496 // Fall through! | 497 // Fall through! |
497 | 498 |
498 case USB_TRANSFER_BULK: | 499 case UsbTransferType::BULK: |
499 case USB_TRANSFER_INTERRUPT: | 500 case UsbTransferType::INTERRUPT: |
500 TransferComplete(ConvertTransferStatus(platform_transfer_->status), | 501 TransferComplete(ConvertTransferStatus(platform_transfer_->status), |
501 actual_length); | 502 actual_length); |
502 break; | 503 break; |
503 | 504 |
504 case USB_TRANSFER_ISOCHRONOUS: | 505 case UsbTransferType::ISOCHRONOUS: |
505 IsochronousTransferComplete(); | 506 IsochronousTransferComplete(); |
506 break; | 507 break; |
507 | 508 |
508 default: | 509 default: |
509 NOTREACHED() << "Invalid usb transfer type"; | 510 NOTREACHED() << "Invalid usb transfer type"; |
510 break; | 511 break; |
511 } | 512 } |
512 } | 513 } |
513 | 514 |
514 /* static */ | 515 /* static */ |
515 void LIBUSB_CALL UsbDeviceHandleImpl::Transfer::PlatformCallback( | 516 void LIBUSB_CALL UsbDeviceHandleImpl::Transfer::PlatformCallback( |
516 PlatformUsbTransferHandle platform_transfer) { | 517 PlatformUsbTransferHandle platform_transfer) { |
517 Transfer* transfer = | 518 Transfer* transfer = |
518 reinterpret_cast<Transfer*>(platform_transfer->user_data); | 519 reinterpret_cast<Transfer*>(platform_transfer->user_data); |
519 DCHECK(transfer->platform_transfer_ == platform_transfer); | 520 DCHECK(transfer->platform_transfer_ == platform_transfer); |
520 transfer->ProcessCompletion(); | 521 transfer->ProcessCompletion(); |
521 } | 522 } |
522 | 523 |
523 void UsbDeviceHandleImpl::Transfer::TransferComplete(UsbTransferStatus status, | 524 void UsbDeviceHandleImpl::Transfer::TransferComplete(UsbTransferStatus status, |
524 size_t bytes_transferred) { | 525 size_t bytes_transferred) { |
525 base::Closure closure; | 526 base::Closure closure; |
526 if (transfer_type_ == USB_TRANSFER_ISOCHRONOUS) { | 527 if (transfer_type_ == UsbTransferType::ISOCHRONOUS) { |
527 DCHECK_NE(LIBUSB_TRANSFER_COMPLETED, platform_transfer_->status); | 528 DCHECK_NE(LIBUSB_TRANSFER_COMPLETED, platform_transfer_->status); |
528 std::vector<IsochronousPacket> packets(platform_transfer_->num_iso_packets); | 529 std::vector<IsochronousPacket> packets(platform_transfer_->num_iso_packets); |
529 for (size_t i = 0; i < packets.size(); ++i) { | 530 for (size_t i = 0; i < packets.size(); ++i) { |
530 packets[i].length = platform_transfer_->iso_packet_desc[i].length; | 531 packets[i].length = platform_transfer_->iso_packet_desc[i].length; |
531 packets[i].transferred_length = 0; | 532 packets[i].transferred_length = 0; |
532 packets[i].status = status; | 533 packets[i].status = status; |
533 } | 534 } |
534 closure = base::Bind(iso_callback_, buffer_, packets); | 535 closure = base::Bind(iso_callback_, buffer_, packets); |
535 } else { | 536 } else { |
536 closure = base::Bind(callback_, status, buffer_, bytes_transferred); | 537 closure = base::Bind(callback_, status, buffer_, bytes_transferred); |
(...skipping 153 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
690 if (transfer->claimed_interface() == interface_claimer) { | 691 if (transfer->claimed_interface() == interface_claimer) { |
691 transfer->Cancel(); | 692 transfer->Cancel(); |
692 } | 693 } |
693 } | 694 } |
694 | 695 |
695 blocking_task_runner_->PostTask( | 696 blocking_task_runner_->PostTask( |
696 FROM_HERE, base::Bind(&UsbDeviceHandleImpl::ClearHaltOnBlockingThread, | 697 FROM_HERE, base::Bind(&UsbDeviceHandleImpl::ClearHaltOnBlockingThread, |
697 this, endpoint, callback)); | 698 this, endpoint, callback)); |
698 } | 699 } |
699 | 700 |
700 void UsbDeviceHandleImpl::ControlTransfer(UsbEndpointDirection direction, | 701 void UsbDeviceHandleImpl::ControlTransfer(UsbTransferDirection direction, |
701 TransferRequestType request_type, | 702 UsbControlTransferType request_type, |
702 TransferRecipient recipient, | 703 UsbControlTransferRecipient recipient, |
703 uint8_t request, | 704 uint8_t request, |
704 uint16_t value, | 705 uint16_t value, |
705 uint16_t index, | 706 uint16_t index, |
706 scoped_refptr<net::IOBuffer> buffer, | 707 scoped_refptr<net::IOBuffer> buffer, |
707 size_t length, | 708 size_t length, |
708 unsigned int timeout, | 709 unsigned int timeout, |
709 const TransferCallback& callback) { | 710 const TransferCallback& callback) { |
710 if (task_runner_->BelongsToCurrentThread()) { | 711 if (task_runner_->BelongsToCurrentThread()) { |
711 ControlTransferInternal(direction, request_type, recipient, request, value, | 712 ControlTransferInternal(direction, request_type, recipient, request, value, |
712 index, buffer, length, timeout, task_runner_, | 713 index, buffer, length, timeout, task_runner_, |
713 callback); | 714 callback); |
714 } else { | 715 } else { |
715 task_runner_->PostTask( | 716 task_runner_->PostTask( |
716 FROM_HERE, base::Bind(&UsbDeviceHandleImpl::ControlTransferInternal, | 717 FROM_HERE, base::Bind(&UsbDeviceHandleImpl::ControlTransferInternal, |
717 this, direction, request_type, recipient, request, | 718 this, direction, request_type, recipient, request, |
718 value, index, buffer, length, timeout, | 719 value, index, buffer, length, timeout, |
719 base::ThreadTaskRunnerHandle::Get(), callback)); | 720 base::ThreadTaskRunnerHandle::Get(), callback)); |
720 } | 721 } |
721 } | 722 } |
722 | 723 |
723 void UsbDeviceHandleImpl::IsochronousTransferIn( | 724 void UsbDeviceHandleImpl::IsochronousTransferIn( |
724 uint8_t endpoint_number, | 725 uint8_t endpoint_number, |
725 const std::vector<uint32_t>& packet_lengths, | 726 const std::vector<uint32_t>& packet_lengths, |
726 unsigned int timeout, | 727 unsigned int timeout, |
727 const IsochronousTransferCallback& callback) { | 728 const IsochronousTransferCallback& callback) { |
728 uint8_t endpoint_address = | 729 uint8_t endpoint_address = |
729 ConvertTransferDirection(USB_DIRECTION_INBOUND) | endpoint_number; | 730 ConvertTransferDirection(UsbTransferDirection::INBOUND) | endpoint_number; |
730 if (task_runner_->BelongsToCurrentThread()) { | 731 if (task_runner_->BelongsToCurrentThread()) { |
731 IsochronousTransferInInternal(endpoint_address, packet_lengths, timeout, | 732 IsochronousTransferInInternal(endpoint_address, packet_lengths, timeout, |
732 task_runner_, callback); | 733 task_runner_, callback); |
733 } else { | 734 } else { |
734 task_runner_->PostTask( | 735 task_runner_->PostTask( |
735 FROM_HERE, | 736 FROM_HERE, |
736 base::Bind(&UsbDeviceHandleImpl::IsochronousTransferInInternal, this, | 737 base::Bind(&UsbDeviceHandleImpl::IsochronousTransferInInternal, this, |
737 endpoint_address, packet_lengths, timeout, | 738 endpoint_address, packet_lengths, timeout, |
738 base::ThreadTaskRunnerHandle::Get(), callback)); | 739 base::ThreadTaskRunnerHandle::Get(), callback)); |
739 } | 740 } |
740 } | 741 } |
741 | 742 |
742 void UsbDeviceHandleImpl::IsochronousTransferOut( | 743 void UsbDeviceHandleImpl::IsochronousTransferOut( |
743 uint8_t endpoint_number, | 744 uint8_t endpoint_number, |
744 scoped_refptr<net::IOBuffer> buffer, | 745 scoped_refptr<net::IOBuffer> buffer, |
745 const std::vector<uint32_t>& packet_lengths, | 746 const std::vector<uint32_t>& packet_lengths, |
746 unsigned int timeout, | 747 unsigned int timeout, |
747 const IsochronousTransferCallback& callback) { | 748 const IsochronousTransferCallback& callback) { |
748 uint8_t endpoint_address = | 749 uint8_t endpoint_address = |
749 ConvertTransferDirection(USB_DIRECTION_OUTBOUND) | endpoint_number; | 750 ConvertTransferDirection(UsbTransferDirection::OUTBOUND) | |
751 endpoint_number; | |
750 if (task_runner_->BelongsToCurrentThread()) { | 752 if (task_runner_->BelongsToCurrentThread()) { |
751 IsochronousTransferOutInternal(endpoint_address, buffer, packet_lengths, | 753 IsochronousTransferOutInternal(endpoint_address, buffer, packet_lengths, |
752 timeout, task_runner_, callback); | 754 timeout, task_runner_, callback); |
753 } else { | 755 } else { |
754 task_runner_->PostTask( | 756 task_runner_->PostTask( |
755 FROM_HERE, | 757 FROM_HERE, |
756 base::Bind(&UsbDeviceHandleImpl::IsochronousTransferOutInternal, this, | 758 base::Bind(&UsbDeviceHandleImpl::IsochronousTransferOutInternal, this, |
757 endpoint_address, buffer, packet_lengths, timeout, | 759 endpoint_address, buffer, packet_lengths, timeout, |
758 base::ThreadTaskRunnerHandle::Get(), callback)); | 760 base::ThreadTaskRunnerHandle::Get(), callback)); |
759 } | 761 } |
760 } | 762 } |
761 | 763 |
762 void UsbDeviceHandleImpl::GenericTransfer(UsbEndpointDirection direction, | 764 void UsbDeviceHandleImpl::GenericTransfer(UsbTransferDirection direction, |
763 uint8_t endpoint_number, | 765 uint8_t endpoint_number, |
764 scoped_refptr<net::IOBuffer> buffer, | 766 scoped_refptr<net::IOBuffer> buffer, |
765 size_t length, | 767 size_t length, |
766 unsigned int timeout, | 768 unsigned int timeout, |
767 const TransferCallback& callback) { | 769 const TransferCallback& callback) { |
768 uint8_t endpoint_address = | 770 uint8_t endpoint_address = |
769 ConvertTransferDirection(direction) | endpoint_number; | 771 ConvertTransferDirection(direction) | endpoint_number; |
770 if (task_runner_->BelongsToCurrentThread()) { | 772 if (task_runner_->BelongsToCurrentThread()) { |
771 GenericTransferInternal(endpoint_address, buffer, length, timeout, | 773 GenericTransferInternal(endpoint_address, buffer, length, timeout, |
772 task_runner_, callback); | 774 task_runner_, callback); |
(...skipping 189 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
962 | 964 |
963 scoped_refptr<UsbDeviceHandleImpl::InterfaceClaimer> | 965 scoped_refptr<UsbDeviceHandleImpl::InterfaceClaimer> |
964 UsbDeviceHandleImpl::GetClaimedInterfaceForEndpoint(uint8_t endpoint) { | 966 UsbDeviceHandleImpl::GetClaimedInterfaceForEndpoint(uint8_t endpoint) { |
965 const auto endpoint_it = endpoint_map_.find(endpoint); | 967 const auto endpoint_it = endpoint_map_.find(endpoint); |
966 if (endpoint_it != endpoint_map_.end()) | 968 if (endpoint_it != endpoint_map_.end()) |
967 return claimed_interfaces_[endpoint_it->second.interface->interface_number]; | 969 return claimed_interfaces_[endpoint_it->second.interface->interface_number]; |
968 return nullptr; | 970 return nullptr; |
969 } | 971 } |
970 | 972 |
971 void UsbDeviceHandleImpl::ControlTransferInternal( | 973 void UsbDeviceHandleImpl::ControlTransferInternal( |
972 UsbEndpointDirection direction, | 974 UsbTransferDirection direction, |
973 TransferRequestType request_type, | 975 UsbControlTransferType request_type, |
974 TransferRecipient recipient, | 976 UsbControlTransferRecipient recipient, |
975 uint8_t request, | 977 uint8_t request, |
976 uint16_t value, | 978 uint16_t value, |
977 uint16_t index, | 979 uint16_t index, |
978 scoped_refptr<net::IOBuffer> buffer, | 980 scoped_refptr<net::IOBuffer> buffer, |
979 size_t length, | 981 size_t length, |
980 unsigned int timeout, | 982 unsigned int timeout, |
981 scoped_refptr<base::TaskRunner> callback_task_runner, | 983 scoped_refptr<base::TaskRunner> callback_task_runner, |
982 const TransferCallback& callback) { | 984 const TransferCallback& callback) { |
983 DCHECK(thread_checker_.CalledOnValidThread()); | 985 DCHECK(thread_checker_.CalledOnValidThread()); |
984 | 986 |
985 if (!device_) { | 987 if (!device_) { |
986 RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_DISCONNECT, | 988 RunTransferCallback(callback_task_runner, callback, |
987 buffer, 0); | 989 UsbTransferStatus::DISCONNECT, buffer, 0); |
988 return; | 990 return; |
989 } | 991 } |
990 | 992 |
991 if (!base::IsValueInRangeForNumericType<uint16_t>(length)) { | 993 if (!base::IsValueInRangeForNumericType<uint16_t>(length)) { |
992 USB_LOG(USER) << "Transfer too long."; | 994 USB_LOG(USER) << "Transfer too long."; |
993 RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR, | 995 RunTransferCallback(callback_task_runner, callback, |
994 buffer, 0); | 996 UsbTransferStatus::TRANSFER_ERROR, buffer, 0); |
995 return; | 997 return; |
996 } | 998 } |
997 | 999 |
998 const size_t resized_length = LIBUSB_CONTROL_SETUP_SIZE + length; | 1000 const size_t resized_length = LIBUSB_CONTROL_SETUP_SIZE + length; |
999 scoped_refptr<net::IOBuffer> resized_buffer = | 1001 scoped_refptr<net::IOBuffer> resized_buffer = |
1000 new net::IOBufferWithSize(resized_length); | 1002 new net::IOBufferWithSize(resized_length); |
1001 if (!resized_buffer.get()) { | 1003 if (!resized_buffer.get()) { |
1002 RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR, | 1004 RunTransferCallback(callback_task_runner, callback, |
1003 buffer, 0); | 1005 UsbTransferStatus::TRANSFER_ERROR, buffer, 0); |
1004 return; | 1006 return; |
1005 } | 1007 } |
1006 memcpy(resized_buffer->data() + LIBUSB_CONTROL_SETUP_SIZE, buffer->data(), | 1008 memcpy(resized_buffer->data() + LIBUSB_CONTROL_SETUP_SIZE, buffer->data(), |
1007 length); | 1009 length); |
1008 | 1010 |
1009 std::unique_ptr<Transfer> transfer = Transfer::CreateControlTransfer( | 1011 std::unique_ptr<Transfer> transfer = Transfer::CreateControlTransfer( |
1010 this, CreateRequestType(direction, request_type, recipient), request, | 1012 this, CreateRequestType(direction, request_type, recipient), request, |
1011 value, index, static_cast<uint16_t>(length), resized_buffer, timeout, | 1013 value, index, static_cast<uint16_t>(length), resized_buffer, timeout, |
1012 callback_task_runner, callback); | 1014 callback_task_runner, callback); |
1013 if (!transfer) { | 1015 if (!transfer) { |
1014 RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR, | 1016 RunTransferCallback(callback_task_runner, callback, |
1015 buffer, 0); | 1017 UsbTransferStatus::TRANSFER_ERROR, buffer, 0); |
1016 return; | 1018 return; |
1017 } | 1019 } |
1018 | 1020 |
1019 SubmitTransfer(std::move(transfer)); | 1021 SubmitTransfer(std::move(transfer)); |
1020 } | 1022 } |
1021 | 1023 |
1022 void UsbDeviceHandleImpl::IsochronousTransferInInternal( | 1024 void UsbDeviceHandleImpl::IsochronousTransferInInternal( |
1023 uint8_t endpoint_address, | 1025 uint8_t endpoint_address, |
1024 const std::vector<uint32_t>& packet_lengths, | 1026 const std::vector<uint32_t>& packet_lengths, |
1025 unsigned int timeout, | 1027 unsigned int timeout, |
1026 scoped_refptr<base::TaskRunner> callback_task_runner, | 1028 scoped_refptr<base::TaskRunner> callback_task_runner, |
1027 const IsochronousTransferCallback& callback) { | 1029 const IsochronousTransferCallback& callback) { |
1028 DCHECK(thread_checker_.CalledOnValidThread()); | 1030 DCHECK(thread_checker_.CalledOnValidThread()); |
1029 | 1031 |
1030 if (!device_) { | 1032 if (!device_) { |
1031 ReportIsochronousTransferError(callback_task_runner, callback, | 1033 ReportIsochronousTransferError(callback_task_runner, callback, |
1032 packet_lengths, USB_TRANSFER_DISCONNECT); | 1034 packet_lengths, |
1035 UsbTransferStatus::DISCONNECT); | |
1033 return; | 1036 return; |
1034 } | 1037 } |
1035 | 1038 |
1036 size_t length = | 1039 size_t length = |
1037 std::accumulate(packet_lengths.begin(), packet_lengths.end(), 0u); | 1040 std::accumulate(packet_lengths.begin(), packet_lengths.end(), 0u); |
1038 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(length)); | 1041 scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(length)); |
1039 std::unique_ptr<Transfer> transfer = Transfer::CreateIsochronousTransfer( | 1042 std::unique_ptr<Transfer> transfer = Transfer::CreateIsochronousTransfer( |
1040 this, endpoint_address, buffer, length, packet_lengths, timeout, | 1043 this, endpoint_address, buffer, length, packet_lengths, timeout, |
1041 callback_task_runner, callback); | 1044 callback_task_runner, callback); |
1042 | 1045 |
1043 SubmitTransfer(std::move(transfer)); | 1046 SubmitTransfer(std::move(transfer)); |
1044 } | 1047 } |
1045 | 1048 |
1046 void UsbDeviceHandleImpl::IsochronousTransferOutInternal( | 1049 void UsbDeviceHandleImpl::IsochronousTransferOutInternal( |
1047 uint8_t endpoint_address, | 1050 uint8_t endpoint_address, |
1048 scoped_refptr<net::IOBuffer> buffer, | 1051 scoped_refptr<net::IOBuffer> buffer, |
1049 const std::vector<uint32_t>& packet_lengths, | 1052 const std::vector<uint32_t>& packet_lengths, |
1050 unsigned int timeout, | 1053 unsigned int timeout, |
1051 scoped_refptr<base::TaskRunner> callback_task_runner, | 1054 scoped_refptr<base::TaskRunner> callback_task_runner, |
1052 const IsochronousTransferCallback& callback) { | 1055 const IsochronousTransferCallback& callback) { |
1053 DCHECK(thread_checker_.CalledOnValidThread()); | 1056 DCHECK(thread_checker_.CalledOnValidThread()); |
1054 | 1057 |
1055 if (!device_) { | 1058 if (!device_) { |
1056 ReportIsochronousTransferError(callback_task_runner, callback, | 1059 ReportIsochronousTransferError(callback_task_runner, callback, |
1057 packet_lengths, USB_TRANSFER_DISCONNECT); | 1060 packet_lengths, |
1061 UsbTransferStatus::DISCONNECT); | |
1058 return; | 1062 return; |
1059 } | 1063 } |
1060 | 1064 |
1061 size_t length = | 1065 size_t length = |
1062 std::accumulate(packet_lengths.begin(), packet_lengths.end(), 0u); | 1066 std::accumulate(packet_lengths.begin(), packet_lengths.end(), 0u); |
1063 std::unique_ptr<Transfer> transfer = Transfer::CreateIsochronousTransfer( | 1067 std::unique_ptr<Transfer> transfer = Transfer::CreateIsochronousTransfer( |
1064 this, endpoint_address, buffer, length, packet_lengths, timeout, | 1068 this, endpoint_address, buffer, length, packet_lengths, timeout, |
1065 callback_task_runner, callback); | 1069 callback_task_runner, callback); |
1066 | 1070 |
1067 SubmitTransfer(std::move(transfer)); | 1071 SubmitTransfer(std::move(transfer)); |
1068 } | 1072 } |
1069 | 1073 |
1070 void UsbDeviceHandleImpl::GenericTransferInternal( | 1074 void UsbDeviceHandleImpl::GenericTransferInternal( |
1071 uint8_t endpoint_address, | 1075 uint8_t endpoint_address, |
1072 scoped_refptr<net::IOBuffer> buffer, | 1076 scoped_refptr<net::IOBuffer> buffer, |
1073 size_t length, | 1077 size_t length, |
1074 unsigned int timeout, | 1078 unsigned int timeout, |
1075 scoped_refptr<base::TaskRunner> callback_task_runner, | 1079 scoped_refptr<base::TaskRunner> callback_task_runner, |
1076 const TransferCallback& callback) { | 1080 const TransferCallback& callback) { |
1077 DCHECK(thread_checker_.CalledOnValidThread()); | 1081 DCHECK(thread_checker_.CalledOnValidThread()); |
1078 | 1082 |
1079 if (!device_) { | 1083 if (!device_) { |
1080 RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_DISCONNECT, | 1084 RunTransferCallback(callback_task_runner, callback, |
1081 buffer, 0); | 1085 UsbTransferStatus::DISCONNECT, buffer, 0); |
1082 return; | 1086 return; |
1083 } | 1087 } |
1084 | 1088 |
1085 const auto endpoint_it = endpoint_map_.find(endpoint_address); | 1089 const auto endpoint_it = endpoint_map_.find(endpoint_address); |
1086 if (endpoint_it == endpoint_map_.end()) { | 1090 if (endpoint_it == endpoint_map_.end()) { |
1087 USB_LOG(DEBUG) << "Failed to submit transfer because endpoint " | 1091 USB_LOG(DEBUG) << "Failed to submit transfer because endpoint " |
1088 << static_cast<int>(endpoint_address) | 1092 << static_cast<int>(endpoint_address) |
1089 << " not part of a claimed interface."; | 1093 << " not part of a claimed interface."; |
1090 RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR, | 1094 RunTransferCallback(callback_task_runner, callback, |
1091 buffer, 0); | 1095 UsbTransferStatus::TRANSFER_ERROR, buffer, 0); |
1092 return; | 1096 return; |
1093 } | 1097 } |
1094 | 1098 |
1095 if (!base::IsValueInRangeForNumericType<int>(length)) { | 1099 if (!base::IsValueInRangeForNumericType<int>(length)) { |
1096 USB_LOG(DEBUG) << "Transfer too long."; | 1100 USB_LOG(DEBUG) << "Transfer too long."; |
1097 RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR, | 1101 RunTransferCallback(callback_task_runner, callback, |
1098 buffer, 0); | 1102 UsbTransferStatus::TRANSFER_ERROR, buffer, 0); |
1099 return; | 1103 return; |
1100 } | 1104 } |
1101 | 1105 |
1102 std::unique_ptr<Transfer> transfer; | 1106 std::unique_ptr<Transfer> transfer; |
1103 UsbTransferType transfer_type = endpoint_it->second.endpoint->transfer_type; | 1107 UsbTransferType transfer_type = endpoint_it->second.endpoint->transfer_type; |
1104 if (transfer_type == USB_TRANSFER_BULK) { | 1108 if (transfer_type == UsbTransferType::BULK) { |
1105 transfer = Transfer::CreateBulkTransfer(this, endpoint_address, buffer, | 1109 transfer = Transfer::CreateBulkTransfer(this, endpoint_address, buffer, |
1106 static_cast<int>(length), timeout, | 1110 static_cast<int>(length), timeout, |
1107 callback_task_runner, callback); | 1111 callback_task_runner, callback); |
1108 } else if (transfer_type == USB_TRANSFER_INTERRUPT) { | 1112 } else if (transfer_type == UsbTransferType::INTERRUPT) { |
1109 transfer = Transfer::CreateInterruptTransfer( | 1113 transfer = Transfer::CreateInterruptTransfer( |
1110 this, endpoint_address, buffer, static_cast<int>(length), timeout, | 1114 this, endpoint_address, buffer, static_cast<int>(length), timeout, |
1111 callback_task_runner, callback); | 1115 callback_task_runner, callback); |
1112 } else { | 1116 } else { |
1113 USB_LOG(DEBUG) << "Endpoint " << static_cast<int>(endpoint_address) | 1117 USB_LOG(DEBUG) << "Endpoint " << static_cast<int>(endpoint_address) |
1114 << " is not a bulk or interrupt endpoint."; | 1118 << " is not a bulk or interrupt endpoint."; |
1115 RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR, | 1119 RunTransferCallback(callback_task_runner, callback, |
1116 buffer, 0); | 1120 UsbTransferStatus::TRANSFER_ERROR, buffer, 0); |
1117 return; | 1121 return; |
1118 } | 1122 } |
1119 | 1123 |
1120 SubmitTransfer(std::move(transfer)); | 1124 SubmitTransfer(std::move(transfer)); |
1121 } | 1125 } |
1122 | 1126 |
1123 void UsbDeviceHandleImpl::SubmitTransfer(std::unique_ptr<Transfer> transfer) { | 1127 void UsbDeviceHandleImpl::SubmitTransfer(std::unique_ptr<Transfer> transfer) { |
1124 DCHECK(thread_checker_.CalledOnValidThread()); | 1128 DCHECK(thread_checker_.CalledOnValidThread()); |
1125 | 1129 |
1126 // Transfer is owned by libusb until its completion callback is run. This | 1130 // Transfer is owned by libusb until its completion callback is run. This |
(...skipping 16 matching lines...) Expand all Loading... | |
1143 } else { | 1147 } else { |
1144 transfer->callback_task_runner()->PostTask(FROM_HERE, callback); | 1148 transfer->callback_task_runner()->PostTask(FROM_HERE, callback); |
1145 } | 1149 } |
1146 | 1150 |
1147 // libusb_free_transfer races with libusb_submit_transfer and only work- | 1151 // libusb_free_transfer races with libusb_submit_transfer and only work- |
1148 // around is to make sure to call them on the same thread. | 1152 // around is to make sure to call them on the same thread. |
1149 blocking_task_runner_->DeleteSoon(FROM_HERE, transfer); | 1153 blocking_task_runner_->DeleteSoon(FROM_HERE, transfer); |
1150 } | 1154 } |
1151 | 1155 |
1152 } // namespace device | 1156 } // namespace device |
OLD | NEW |