Shorten USB enumeration control transfer timeouts to 2 seconds

device/usb/usb_descriptors.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_descriptors.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 23 matching lines @@
 const uint8_t kInterfaceDescriptorType = 0x04;
 const uint8_t kEndpointDescriptorType = 0x05;
 const uint8_t kInterfaceAssociationDescriptorType = 11;
 
 const uint8_t kDeviceDescriptorLength = 18;
 const uint8_t kConfigurationDescriptorLength = 9;
 const uint8_t kInterfaceDescriptorLength = 9;
 const uint8_t kEndpointDescriptorLength = 7;
 const uint8_t kInterfaceAssociationDescriptorLength = 8;
 
-const int kControlTransferTimeout = 60000;  // 1 minute
+const int kControlTransferTimeoutMs = 2000;  // 2 seconds
 
 struct UsbInterfaceAssociationDescriptor {
   UsbInterfaceAssociationDescriptor(uint8_t first_interface,
                                     uint8_t interface_count)
       : first_interface(first_interface), interface_count(interface_count) {}
 
   bool operator<(const UsbInterfaceAssociationDescriptor& other) const {
     return first_interface < other.first_interface;
   }
 
@@ skipping 61 matching lines @@
                                   scoped_refptr<IOBuffer> header,
                                   size_t length) {
   if (status == UsbTransferStatus::COMPLETED && length == 4) {
     const uint8_t* data = reinterpret_cast<const uint8_t*>(header->data());
     uint16_t total_length = data[2] | data[3] << 8;
     scoped_refptr<IOBuffer> buffer = new IOBuffer(total_length);
     device_handle->ControlTransfer(
         UsbTransferDirection::INBOUND, UsbControlTransferType::STANDARD,
         UsbControlTransferRecipient::DEVICE, kGetDescriptorRequest,
         kConfigurationDescriptorType << 8 | index, 0, buffer, total_length,
-        kControlTransferTimeout,
+        kControlTransferTimeoutMs,
         base::Bind(&OnReadConfigDescriptor, desc, closure));
   } else {
     LOG(ERROR) << "Failed to read length for configuration "
                << static_cast<int>(index) << ".";
     closure.Run();
   }
 }
 
 void OnReadDeviceDescriptor(
     scoped_refptr<UsbDeviceHandle> device_handle,
@@ skipping 25 matching lines @@
   base::Closure closure = base::BarrierClosure(
       num_configurations,
       base::Bind(OnDoneReadingConfigDescriptors, device_handle,
                  base::Passed(&desc), callback));
   for (uint8_t i = 0; i < num_configurations; ++i) {
     scoped_refptr<IOBufferWithSize> header = new IOBufferWithSize(4);
     device_handle->ControlTransfer(
         UsbTransferDirection::INBOUND, UsbControlTransferType::STANDARD,
         UsbControlTransferRecipient::DEVICE, kGetDescriptorRequest,
         kConfigurationDescriptorType << 8 | i, 0, header, header->size(),
-        kControlTransferTimeout,
+        kControlTransferTimeoutMs,
         base::Bind(&OnReadConfigDescriptorHeader, device_handle, desc_ptr, i,
                    closure));
   }
 }
 
 void StoreStringDescriptor(IndexMap::iterator it,
                            const base::Closure& callback,
                            const base::string16& string) {
   it->second = string;
   callback.Run();
@@ skipping 18 matching lines @@
 void ReadStringDescriptor(
     scoped_refptr<UsbDeviceHandle> device_handle,
     uint8_t index,
     uint16_t language_id,
     const base::Callback<void(const base::string16&)>& callback) {
   scoped_refptr<IOBufferWithSize> buffer = new IOBufferWithSize(255);
   device_handle->ControlTransfer(
       UsbTransferDirection::INBOUND, UsbControlTransferType::STANDARD,
       UsbControlTransferRecipient::DEVICE, kGetDescriptorRequest,
       kStringDescriptorType << 8 | index, language_id, buffer, buffer->size(),
-      kControlTransferTimeout, base::Bind(&OnReadStringDescriptor, callback));
+      kControlTransferTimeoutMs, base::Bind(&OnReadStringDescriptor, callback));
 }
 
 void OnReadLanguageIds(scoped_refptr<UsbDeviceHandle> device_handle,
                        IndexMapPtr index_map,
                        const base::Callback<void(IndexMapPtr)>& callback,
                        const base::string16& languages) {
   // Default to English unless the device provides a language and then just pick
   // the first one.
   uint16_t language_id = languages.empty() ? 0x0409 : languages[0];
 
@@ skipping 274 matching lines @@
 
 void ReadUsbDescriptors(scoped_refptr<UsbDeviceHandle> device_handle,
                         const base::Callback<void(
                             std::unique_ptr<UsbDeviceDescriptor>)>& callback) {
   scoped_refptr<IOBufferWithSize> buffer =
       new IOBufferWithSize(kDeviceDescriptorLength);
   device_handle->ControlTransfer(
       UsbTransferDirection::INBOUND, UsbControlTransferType::STANDARD,
       UsbControlTransferRecipient::DEVICE, kGetDescriptorRequest,
       kDeviceDescriptorType << 8, 0, buffer, buffer->size(),
-      kControlTransferTimeout,
+      kControlTransferTimeoutMs,
       base::Bind(&OnReadDeviceDescriptor, device_handle, callback));
 }
 
 bool ParseUsbStringDescriptor(const std::vector<uint8_t>& descriptor,
                               base::string16* output) {
   if (descriptor.size() < 2 || descriptor[1] != kStringDescriptorType)
     return false;
 
   // Let the device return a buffer larger than the actual string but prefer the
   // length reported inside the descriptor.
@@ skipping 19 matching lines @@
     callback.Run(std::move(index_map));
     return;
   }
 
   ReadStringDescriptor(device_handle, 0, 0,
                        base::Bind(&OnReadLanguageIds, device_handle,
                                   base::Passed(&index_map), callback));
 }
 
 }  // namespace device