Convert device::UsbConfigDescriptor and friends to structs.

chrome/browser/devtools/device/usb/android_usb_device.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 "chrome/browser/devtools/device/usb/android_usb_device.h"
 
 #include <set>
 
 #include "base/barrier_closure.h"
 #include "base/base64.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/devtools/device/usb/android_rsa.h"
 #include "chrome/browser/devtools/device/usb/android_usb_socket.h"
 #include "content/public/browser/browser_thread.h"
 #include "crypto/rsa_private_key.h"
 #include "device/core/device_client.h"
+#include "device/usb/usb_descriptors.h"
 #include "device/usb/usb_device.h"
-#include "device/usb/usb_interface.h"
 #include "device/usb/usb_service.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/socket/stream_socket.h"
 
 using device::UsbConfigDescriptor;
 using device::UsbDevice;
 using device::UsbDeviceHandle;
-using device::UsbInterfaceAltSettingDescriptor;
 using device::UsbInterfaceDescriptor;
 using device::UsbEndpointDescriptor;
 using device::UsbService;
 using device::UsbTransferStatus;
 
 namespace {
 
 const size_t kHeaderSize = 24;
 
 const int kAdbClass = 0xff;
 const int kAdbSubclass = 0x42;
 const int kAdbProtocol = 0x1;
 
 const int kUsbTimeout = 0;
 
 const uint32 kMaxPayload = 4096;
 const uint32 kVersion = 0x01000000;
 
 static const char kHostConnectMessage[] = "host::";
 
 using content::BrowserThread;
 
 typedef std::vector<scoped_refptr<UsbDevice> > UsbDevices;
 typedef std::set<scoped_refptr<UsbDevice> > UsbDeviceSet;
 
 // Stores android wrappers around claimed usb devices on caller thread.
 base::LazyInstance<std::vector<AndroidUsbDevice*> >::Leaky g_devices =
     LAZY_INSTANCE_INITIALIZER;
 
-bool IsAndroidInterface(scoped_refptr<const UsbInterfaceDescriptor> interface) {
-  if (interface->GetNumAltSettings() == 0)
-    return false;
-
-  scoped_refptr<const UsbInterfaceAltSettingDescriptor> idesc =
-      interface->GetAltSetting(0);
-
-  if (idesc->GetInterfaceClass() != kAdbClass ||
-      idesc->GetInterfaceSubclass() != kAdbSubclass ||
-      idesc->GetInterfaceProtocol() != kAdbProtocol ||
-      idesc->GetNumEndpoints() != 2) {
+bool IsAndroidInterface(const UsbInterfaceDescriptor& interface) {
+  if (interface.alternate_setting != 0 ||

[dgozman, 2014/09/11 11:23:47]

Did you change the meaning of this field? If not, this should be
|interface.alternate_setting == 0|.

[Reilly Grant (use Gerrit), 2014/09/11 17:49:26]

I didn't change the meaning. alternate_setting == 0 means this interface is the
primary setting. This code was making (and continues to make) the assumption
that the ADB interface will be the default and it will not need to issue a
SET_INTERFACE request.

[dgozman, 2014/09/12 11:03:34]

Thanks for clarification, was not obvious to me.

+      interface.interface_class != kAdbClass ||
+      interface.interface_subclass != kAdbSubclass ||
+      interface.interface_protocol != kAdbProtocol ||
+      interface.endpoints.size() != 2) {
     return false;
   }
   return true;
 }
 
 scoped_refptr<AndroidUsbDevice> ClaimInterface(
     crypto::RSAPrivateKey* rsa_key,
     scoped_refptr<UsbDeviceHandle> usb_handle,
-    scoped_refptr<const UsbInterfaceDescriptor> interface,
-    int interface_id) {
-  scoped_refptr<const UsbInterfaceAltSettingDescriptor> idesc =
-      interface->GetAltSetting(0);
-
+    const UsbInterfaceDescriptor& interface) {
   int inbound_address = 0;
   int outbound_address = 0;
   int zero_mask = 0;
 
-  for (size_t i = 0; i < idesc->GetNumEndpoints(); ++i) {
-    scoped_refptr<const UsbEndpointDescriptor> edesc =
-        idesc->GetEndpoint(i);
-    if (edesc->GetTransferType() != device::USB_TRANSFER_BULK)
+  for (size_t i = 0; i < interface.endpoints.size(); ++i) {
+    const UsbEndpointDescriptor& edesc = interface.endpoints[i];
+    if (edesc.transfer_type != device::USB_TRANSFER_BULK)
       continue;
-    if (edesc->GetDirection() == device::USB_DIRECTION_INBOUND)
-      inbound_address = edesc->GetAddress();
+    if (edesc.direction == device::USB_DIRECTION_INBOUND)
+      inbound_address = edesc.address;
     else
-      outbound_address = edesc->GetAddress();
-    zero_mask = edesc->GetMaximumPacketSize() - 1;
+      outbound_address = edesc.address;
+    zero_mask = edesc.maximum_packet_size - 1;
   }
 
   if (inbound_address == 0 || outbound_address == 0)
     return NULL;
 
-  if (!usb_handle->ClaimInterface(interface_id))
+  if (!usb_handle->ClaimInterface(interface.interface_number))
     return NULL;
 
   base::string16 serial;
   if (!usb_handle->GetSerial(&serial) || serial.empty())
     return NULL;
 
-  return new AndroidUsbDevice(rsa_key, usb_handle, base::UTF16ToASCII(serial),
-                              inbound_address, outbound_address, zero_mask,
-                              interface_id);
+  return new AndroidUsbDevice(rsa_key,
+                              usb_handle,
+                              base::UTF16ToASCII(serial),
+                              inbound_address,
+                              outbound_address,
+                              zero_mask,
+                              interface.interface_number);
 }
 
 uint32 Checksum(const std::string& data) {
   unsigned char* x = (unsigned char*)data.data();
   int count = data.length();
   uint32 sum = 0;
   while (count-- > 0)
     sum += *x++;
   return sum;
 }
@@ skipping 75 matching lines @@
 
 static void OpenAndroidDeviceOnFileThread(
     AndroidUsbDevices* devices,
     crypto::RSAPrivateKey* rsa_key,
     const base::Closure& barrier,
     scoped_refptr<UsbDevice> device,
     int interface_id,
     bool success) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   if (success) {
-    scoped_refptr<UsbConfigDescriptor> config = device->ListInterfaces();
+    const UsbConfigDescriptor& config = device->GetConfiguration();
     scoped_refptr<UsbDeviceHandle> usb_handle = device->Open();
     if (usb_handle.get()) {
       scoped_refptr<AndroidUsbDevice> android_device =
-        ClaimInterface(rsa_key, usb_handle, config->GetInterface(interface_id),
-                       interface_id);
+          ClaimInterface(rsa_key, usb_handle, config.interfaces[interface_id]);
       if (android_device.get())
         devices->push_back(android_device.get());
       else
         usb_handle->Close();
     }
   }
   barrier.Run();
 }
 
 static int CountOnFileThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   UsbService* service = device::DeviceClient::Get()->GetUsbService();
   UsbDevices usb_devices;
   if (service != NULL)
     service->GetDevices(&usb_devices);
   int device_count = 0;
   for (UsbDevices::iterator it = usb_devices.begin(); it != usb_devices.end();
        ++it) {
-    scoped_refptr<UsbConfigDescriptor> config = (*it)->ListInterfaces();
-    if (!config.get())
-      continue;
+    const UsbConfigDescriptor& config = (*it)->GetConfiguration();
 
-    for (size_t j = 0; j < config->GetNumInterfaces(); ++j) {
-      if (IsAndroidInterface(config->GetInterface(j)))
+    for (size_t j = 0; j < config.interfaces.size(); ++j) {
+      if (IsAndroidInterface(config.interfaces[j])) {
         ++device_count;
+      }
     }
   }
   return device_count;
 }
 
 static void EnumerateOnFileThread(
     crypto::RSAPrivateKey* rsa_key,
     const AndroidUsbDevicesCallback& callback,
     scoped_refptr<base::MessageLoopProxy> caller_message_loop_proxy) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   UsbService* service = device::DeviceClient::Get()->GetUsbService();
   UsbDevices usb_devices;
   if (service != NULL)
     service->GetDevices(&usb_devices);
 
   // Add new devices.
   AndroidUsbDevices* devices = new AndroidUsbDevices();
   base::Closure barrier = base::BarrierClosure(
       usb_devices.size(), base::Bind(&RespondOnFileThread,
                                      callback,
                                      devices,
                                      caller_message_loop_proxy));
 
   for (UsbDevices::iterator it = usb_devices.begin(); it != usb_devices.end();
        ++it) {
-    scoped_refptr<UsbConfigDescriptor> config = (*it)->ListInterfaces();
-    if (!config.get()) {
-      barrier.Run();
-      continue;
-    }
+    const UsbConfigDescriptor& config = (*it)->GetConfiguration();
 
     bool has_android_interface = false;
-    for (size_t j = 0; j < config->GetNumInterfaces(); ++j) {
-      if (!IsAndroidInterface(config->GetInterface(j)))
+    for (size_t j = 0; j < config.interfaces.size(); ++j) {
+      if (!IsAndroidInterface(config.interfaces[j]))
         continue;
 
       // Request permission on Chrome OS.
 #if defined(OS_CHROMEOS)
       (*it)->RequestUsbAccess(j, base::Bind(&OpenAndroidDeviceOnFileThread,
                                             devices, rsa_key, barrier, *it, j));
 #else
       OpenAndroidDeviceOnFileThread(devices, rsa_key, barrier, *it, j, true);
 #endif  // defined(OS_CHROMEOS)
 
@@ skipping 368 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&ReleaseInterface, usb_handle, interface_id_));
 }
 
 void AndroidUsbDevice::SocketDeleted(uint32 socket_id) {
   DCHECK(message_loop_ == base::MessageLoop::current());
 
   sockets_.erase(socket_id);
 }