Shorten USB enumeration control transfer timeouts to 2 seconds

device/usb/webusb_descriptors.cc

 // Copyright 2015 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/webusb_descriptors.h"
 
 #include <stddef.h>
 
 #include <iterator>
 #include <map>
@@ skipping 27 matching lines @@
 // These constants are defined by the WebUSB specification:
 // http://wicg.github.io/webusb/
 const uint8_t kGetAllowedOriginsRequest = 0x01;
 const uint8_t kGetUrlRequest = 0x02;
 
 const uint8_t kWebUsbCapabilityUUID[16] = {
     // Little-endian encoding of {3408b638-09a9-47a0-8bfd-a0768815b665}.
     0x38, 0xB6, 0x08, 0x34, 0xA9, 0x09, 0xA0, 0x47,
     0x8B, 0xFD, 0xA0, 0x76, 0x88, 0x15, 0xB6, 0x65};
 
-const int kControlTransferTimeout = 60000;  // 1 minute
+const int kControlTransferTimeoutMs = 2000;  // 2 seconds
 
 using ReadWebUsbDescriptorsCallback =
     base::Callback<void(std::unique_ptr<WebUsbAllowedOrigins> allowed_origins,
                         const GURL& landing_page)>;
 
 using ReadWebUsbAllowedOriginsCallback =
     base::Callback<void(std::unique_ptr<WebUsbAllowedOrigins> allowed_origins)>;
 
 // Parses a WebUSB Function Subset Header:
 // http://wicg.github.io/webusb/#dfn-function-subset-header
@@ skipping 152 matching lines @@
 // |url_map| and then runs |callback|.
 void ReadUrlDescriptor(scoped_refptr<UsbDeviceHandle> device_handle,
                        uint8_t vendor_code,
                        std::map<uint8_t, GURL>* url_map,
                        uint8_t index,
                        const base::Closure& callback) {
   scoped_refptr<IOBufferWithSize> buffer = new IOBufferWithSize(255);
   device_handle->ControlTransfer(
       UsbTransferDirection::INBOUND, UsbControlTransferType::VENDOR,
       UsbControlTransferRecipient::DEVICE, vendor_code, index, kGetUrlRequest,
-      buffer, buffer->size(), kControlTransferTimeout,
+      buffer, buffer->size(), kControlTransferTimeoutMs,
       base::Bind(&OnReadUrlDescriptor, url_map, index, callback));
 }
 
 // Reads URL descriptors from the device so that it can fill |allowed_origins|
 // with the GURLs matching the indicies already collected.
 void ReadUrlDescriptors(scoped_refptr<UsbDeviceHandle> device_handle,
                         uint8_t vendor_code,
                         uint8_t landing_page_id,
                         const ReadWebUsbDescriptorsCallback& callback,
                         std::unique_ptr<WebUsbAllowedOrigins> allowed_origins) {
@@ skipping 62 matching lines @@
     return;
   }
 
   const uint8_t* data = reinterpret_cast<uint8_t*>(buffer->data());
   uint16_t new_length = data[2] | (data[3] << 8);
   scoped_refptr<IOBufferWithSize> new_buffer = new IOBufferWithSize(new_length);
   device_handle->ControlTransfer(
       UsbTransferDirection::INBOUND, UsbControlTransferType::VENDOR,
       UsbControlTransferRecipient::DEVICE, vendor_code, 0,
       kGetAllowedOriginsRequest, new_buffer, new_buffer->size(),
-      kControlTransferTimeout,
+      kControlTransferTimeoutMs,
       base::Bind(&OnReadWebUsbAllowedOrigins, callback));
 }
 
 void ReadWebUsbAllowedOrigins(
     scoped_refptr<UsbDeviceHandle> device_handle,
     uint8_t vendor_code,
     const ReadWebUsbAllowedOriginsCallback& callback) {
   scoped_refptr<IOBufferWithSize> buffer = new IOBufferWithSize(4);
   device_handle->ControlTransfer(
       UsbTransferDirection::INBOUND, UsbControlTransferType::VENDOR,
       UsbControlTransferRecipient::DEVICE, vendor_code, 0,
       kGetAllowedOriginsRequest, buffer, buffer->size(),
-      kControlTransferTimeout,
+      kControlTransferTimeoutMs,
       base::Bind(&OnReadWebUsbAllowedOriginsHeader, device_handle, callback,
                  vendor_code));
 }
 
 void OnReadBosDescriptor(scoped_refptr<UsbDeviceHandle> device_handle,
                          const ReadWebUsbDescriptorsCallback& callback,
                          UsbTransferStatus status,
                          scoped_refptr<net::IOBuffer> buffer,
                          size_t length) {
   if (status != UsbTransferStatus::COMPLETED) {
@@ skipping 26 matching lines @@
     return;
   }
 
   const uint8_t* data = reinterpret_cast<uint8_t*>(buffer->data());
   uint16_t new_length = data[2] | (data[3] << 8);
   scoped_refptr<IOBufferWithSize> new_buffer = new IOBufferWithSize(new_length);
   device_handle->ControlTransfer(
       UsbTransferDirection::INBOUND, UsbControlTransferType::STANDARD,
       UsbControlTransferRecipient::DEVICE, kGetDescriptorRequest,
       kBosDescriptorType << 8, 0, new_buffer, new_buffer->size(),
-      kControlTransferTimeout,
+      kControlTransferTimeoutMs,
       base::Bind(&OnReadBosDescriptor, device_handle, callback));
 }
 
 }  // namespace
 
 WebUsbFunctionSubset::WebUsbFunctionSubset() : first_interface(0) {}
 
 WebUsbFunctionSubset::WebUsbFunctionSubset(const WebUsbFunctionSubset& other) =
     default;
 
@@ skipping 192 matching lines @@
   return true;
 }
 
 void ReadWebUsbDescriptors(scoped_refptr<UsbDeviceHandle> device_handle,
                            const ReadWebUsbDescriptorsCallback& callback) {
   scoped_refptr<IOBufferWithSize> buffer = new IOBufferWithSize(5);
   device_handle->ControlTransfer(
       UsbTransferDirection::INBOUND, UsbControlTransferType::STANDARD,
       UsbControlTransferRecipient::DEVICE, kGetDescriptorRequest,
       kBosDescriptorType << 8, 0, buffer, buffer->size(),
-      kControlTransferTimeout,
+      kControlTransferTimeoutMs,
       base::Bind(&OnReadBosDescriptorHeader, device_handle, callback));
 }
 
 bool FindInWebUsbAllowedOrigins(
     const device::WebUsbAllowedOrigins* allowed_origins,
     const GURL& origin,
     base::Optional<uint8_t> config_value,
     base::Optional<uint8_t> first_interface) {
   if (!allowed_origins)
     return false;
@@ skipping 14 matching lines @@
 
       if (base::ContainsValue(function.origins, origin))
         return true;
     }
   }
 
   return false;
 }
 
 }  // namespace device