Add a service to track devices selected by the user.

device/usb/usb_device_handle_impl.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "device/usb/usb_device_handle_impl.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 501 matching lines @@
     return false;
   }
 
   if (desc.iSerialNumber == 0) {
     return false;
   }
 
   return GetStringDescriptor(desc.iSerialNumber, serial);
 }
 
-void UsbDeviceHandleImpl::ControlTransfer(
-    const UsbEndpointDirection direction,
-    const TransferRequestType request_type,
-    const TransferRecipient recipient,
-    const uint8 request,
-    const uint16 value,
-    const uint16 index,
-    net::IOBuffer* buffer,
-    const size_t length,
-    const unsigned int timeout,
-    const UsbTransferCallback& callback) {
+void UsbDeviceHandleImpl::ControlTransfer(UsbEndpointDirection direction,
+                                          TransferRequestType request_type,
+                                          TransferRecipient recipient,
+                                          uint8 request,
+                                          uint16 value,
+                                          uint16 index,
+                                          net::IOBuffer* buffer,
+                                          size_t length,
+                                          unsigned int timeout,
+                                          const UsbTransferCallback& callback) {
   if (!device_) {
     callback.Run(USB_TRANSFER_DISCONNECT, buffer, 0);
     return;
   }
 
   const size_t resized_length = LIBUSB_CONTROL_SETUP_SIZE + length;
   scoped_refptr<net::IOBuffer> resized_buffer(
       new net::IOBufferWithSize(static_cast<int>(resized_length)));
   if (!resized_buffer.get()) {
     callback.Run(USB_TRANSFER_ERROR, buffer, 0);
@@ skipping 19 matching lines @@
                                this,
                                timeout);
 
   PostOrSubmitTransfer(transfer,
                        USB_TRANSFER_CONTROL,
                        resized_buffer.get(),
                        resized_length,
                        callback);
 }
 
-void UsbDeviceHandleImpl::BulkTransfer(const UsbEndpointDirection direction,
-                                       const uint8 endpoint,
+void UsbDeviceHandleImpl::BulkTransfer(UsbEndpointDirection direction,
+                                       uint8 endpoint,
                                        net::IOBuffer* buffer,
-                                       const size_t length,
-                                       const unsigned int timeout,
+                                       size_t length,
+                                       unsigned int timeout,
                                        const UsbTransferCallback& callback) {
   if (!device_) {
     callback.Run(USB_TRANSFER_DISCONNECT, buffer, 0);
     return;
   }
 
   PlatformUsbTransferHandle const transfer = libusb_alloc_transfer(0);
   const uint8 new_endpoint = ConvertTransferDirection(direction) | endpoint;
   libusb_fill_bulk_transfer(transfer,
                             handle_,
                             new_endpoint,
                             reinterpret_cast<uint8*>(buffer->data()),
                             static_cast<int>(length),
                             &UsbDeviceHandleImpl::PlatformTransferCallback,
                             this,
                             timeout);
 
   PostOrSubmitTransfer(transfer, USB_TRANSFER_BULK, buffer, length, callback);
 }
 
 void UsbDeviceHandleImpl::InterruptTransfer(
-    const UsbEndpointDirection direction,
-    const uint8 endpoint,
+    UsbEndpointDirection direction,
+    uint8 endpoint,
     net::IOBuffer* buffer,
-    const size_t length,
-    const unsigned int timeout,
+    size_t length,
+    unsigned int timeout,
     const UsbTransferCallback& callback) {
   if (!device_) {
     callback.Run(USB_TRANSFER_DISCONNECT, buffer, 0);
     return;
   }
 
   PlatformUsbTransferHandle const transfer = libusb_alloc_transfer(0);
   const uint8 new_endpoint = ConvertTransferDirection(direction) | endpoint;
   libusb_fill_interrupt_transfer(transfer,
                                  handle_,
                                  new_endpoint,
                                  reinterpret_cast<uint8*>(buffer->data()),
                                  static_cast<int>(length),
                                  &UsbDeviceHandleImpl::PlatformTransferCallback,
                                  this,
                                  timeout);
 
   PostOrSubmitTransfer(
       transfer, USB_TRANSFER_INTERRUPT, buffer, length, callback);
 }
 
 void UsbDeviceHandleImpl::IsochronousTransfer(
-    const UsbEndpointDirection direction,
-    const uint8 endpoint,
+    UsbEndpointDirection direction,
+    uint8 endpoint,
     net::IOBuffer* buffer,
-    const size_t length,
-    const unsigned int packets,
-    const unsigned int packet_length,
-    const unsigned int timeout,
+    size_t length,
+    unsigned int packets,
+    unsigned int packet_length,
+    unsigned int timeout,
     const UsbTransferCallback& callback) {
   if (!device_) {
     callback.Run(USB_TRANSFER_DISCONNECT, buffer, 0);
     return;
   }
 
   const uint64 total_length = packets * packet_length;
   CHECK(packets <= length && total_length <= length)
       << "transfer length is too small";
 
@@ skipping 122 matching lines @@
   // Attempt-release all the interfaces.
   // It will be retained until the transfer cancellation is finished.
   claimed_interfaces_.clear();
 
   // Cannot close device handle here. Need to wait for libusb_cancel_transfer to
   // finish.
   device_ = NULL;
 }
 
 }  // namespace device