[WebMIDI] [Android] Set appropriate port properties.

media/midi/usb_midi_descriptor_parser.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 "media/midi/usb_midi_descriptor_parser.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 
@@ skipping 61 matching lines @@
                                     size_t size,
                                     std::vector<UsbMidiJack>* jacks) {
   jacks->clear();
   bool result = ParseInternal(device, data, size, jacks);
   if (!result)
     jacks->clear();
   Clear();
   return result;
 }
 
+bool UsbMidiDescriptorParser::ParseDeviceInfo(
+    const uint8* data, size_t size, DeviceInfo* info) {
+  for (const uint8* current = data;
+       current < data + size;
+       current += current[0]) {
+    uint8 length = current[0];
+    if (length < 2) {
+      DVLOG(1) << "Descriptor Type is not accessible.";
+      return false;
+    }
+    if (current + length > data + size) {
+      DVLOG(1) << "The header size is incorrect.";
+      return false;
+    }
+    DescriptorType descriptor_type = static_cast<DescriptorType>(current[1]);
+    if (descriptor_type != TYPE_DEVICE)
+      continue;
+    bool result = ParseDevice(current, length, info);
+    if (!result)
+      *info = DeviceInfo();

[Takashi Toyoshima, 2015/04/22 05:25:13]

Shall we initialize *info always at the beginning of this function instead of
here and at line 105 just in case?

For now, behaviors are not consistent, e.g., code paths at line 90, and 95 do
not initialize *info at all for error cases, but line 105 does.

Or, we can just remove line 101 and 105 since caller must create it via
constructor with right initialization.

[yhirano, 2015/04/22 06:11:09]

You're right, thanks. Done.

+    return result;
+  }
+  // No DEVICE descriptor is found.
+  *info = DeviceInfo();
+  return false;
+}
+
 bool UsbMidiDescriptorParser::ParseInternal(UsbMidiDevice* device,
                                             const uint8* data,
                                             size_t size,
                                             std::vector<UsbMidiJack>* jacks) {
   for (const uint8* current = data;
        current < data + size;
        current += current[0]) {
     uint8 length = current[0];
     if (length < 2) {
       DVLOG(1) << "Descriptor Type is not accessible.";
@@ skipping 30 matching lines @@
           return false;
         break;
       default:
         // Ignore uninteresting types.
         break;
     }
   }
   return true;
 }
 
+bool UsbMidiDescriptorParser::ParseDevice(
+    const uint8* data, size_t size, DeviceInfo* info) {
+  if (size < 0x12) {
+    DVLOG(1) << "DEVICE header size is incorrect.";
+    return false;
+  }
+
+  info->vendor_id = data[8] | (data[9] << 8);
+  info->product_id = data[0xa] | (data[0xb] << 8);
+  info->bcd_device_version = data[0xc] | (data[0xd] << 8);
+  info->manufacturer_index = data[0xe];
+  info->product_index = data[0xf];
+  return true;
+}
+
 bool UsbMidiDescriptorParser::ParseInterface(const uint8* data, size_t size) {
   if (size != 9) {
     DVLOG(1) << "INTERFACE header size is incorrect.";
     return false;
   }
   incomplete_jacks_.clear();
 
   uint8 interface_class = data[5];
   uint8 interface_subclass = data[6];
 
@@ skipping 84 matching lines @@
 }
 
 void UsbMidiDescriptorParser::Clear() {
   is_parsing_usb_midi_interface_ = false;
   current_endpoint_address_ = 0;
   current_cable_number_ = 0;
   incomplete_jacks_.clear();
 }
 
 }  // namespace media