Parse USB interface association descriptors.

device/usb/usb_descriptors_unittest.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 <stdint.h>
 
 #include "base/bind.h"
 #include "base/strings/utf_string_conversions.h"
 #include "device/usb/mock_usb_device_handle.h"
 #include "device/usb/usb_descriptors.h"
@@ skipping 14 matching lines @@
 void ExpectStringDescriptors(
     scoped_ptr<std::map<uint8_t, base::string16>> string_map) {
   EXPECT_EQ(3u, string_map->size());
   EXPECT_EQ(base::ASCIIToUTF16("String 1"), (*string_map)[1]);
   EXPECT_EQ(base::ASCIIToUTF16("String 2"), (*string_map)[2]);
   EXPECT_EQ(base::ASCIIToUTF16("String 3"), (*string_map)[3]);
 }
 
 class UsbDescriptorsTest : public ::testing::Test {};
 
+TEST_F(UsbDescriptorsTest, NoInterfaceAssociations) {
+  UsbConfigDescriptor config(1, false, false, 0);
+  config.interfaces.emplace_back(0, 0, 255, 255, 255);
+  config.interfaces.emplace_back(0, 1, 255, 255, 255);
+  config.interfaces.emplace_back(1, 0, 255, 255, 255);
+  config.AssignFirstInterfaceNumbers();
+
+  EXPECT_EQ(0, config.interfaces[0].first_interface);
+  EXPECT_EQ(0, config.interfaces[1].first_interface);
+  EXPECT_EQ(1, config.interfaces[2].first_interface);
+}
+
+TEST_F(UsbDescriptorsTest, InterfaceAssociations) {
+  // Links interfaces 0 and 1 into a single function.
+  static const uint8_t kIAD1[] = {0x08, 0x0b, 0x00, 0x02,
+                                  0xff, 0xff, 0xff, 0x00};
+  // Only references a single interface, 2.
+  static const uint8_t kIAD2[] = {0x08, 0x0b, 0x02, 0x01,
+                                  0xff, 0xff, 0xff, 0x00};
+  // Malformed. References interface 3 but bInterfaceCount is 0.
+  static const uint8_t kIAD3[] = {0x08, 0x0b, 0x03, 0x00,
+                                  0xff, 0xff, 0xff, 0x00};
+  // Malformed. References an indefined interface.
+  static const uint8_t kIAD4[] = {0x08, 0x0b, 0x07, 0x00,
+                                  0xff, 0xff, 0xff, 0x00};
+  // Links interfaces 4 and 5 into a single function.
+  static const uint8_t kIAD5[] = {0x08, 0x0b, 0x04, 0x01,
+                                  0xff, 0xff, 0xff, 0x00};
+
+  UsbConfigDescriptor config(1, false, false, 0);
+  config.extra_data.assign(kIAD1, kIAD1 + sizeof(kIAD1));
+  config.extra_data.insert(config.extra_data.end(), kIAD2,
+                           kIAD2 + sizeof(kIAD2));
+  config.interfaces.emplace_back(0, 0, 255, 255, 255);
+  config.interfaces.emplace_back(1, 0, 255, 255, 255);
+  UsbInterfaceDescriptor iface1a(1, 1, 255, 255, 255);
+  iface1a.extra_data.assign(kIAD3, kIAD3 + sizeof(kIAD3));
+  config.interfaces.push_back(std::move(iface1a));
+  config.interfaces.emplace_back(2, 0, 255, 255, 255);
+  config.interfaces.emplace_back(3, 0, 255, 255, 255);
+  UsbInterfaceDescriptor iface4(4, 0, 255, 255, 255);
+  iface4.extra_data.assign(kIAD4, kIAD4 + sizeof(kIAD4));
+  iface4.extra_data.insert(iface4.extra_data.end(), kIAD5,
+                           kIAD5 + sizeof(kIAD5));
+  config.interfaces.push_back(std::move(iface4));
+  config.interfaces.emplace_back(5, 0, 255, 255, 255);
+  config.AssignFirstInterfaceNumbers();
+
+  EXPECT_EQ(0, config.interfaces[0].first_interface);
+  EXPECT_EQ(0, config.interfaces[1].first_interface);
+  EXPECT_EQ(0, config.interfaces[2].first_interface);
+  EXPECT_EQ(2, config.interfaces[3].first_interface);
+  EXPECT_EQ(3, config.interfaces[4].first_interface);
+  EXPECT_EQ(4, config.interfaces[5].first_interface);
+  EXPECT_EQ(4, config.interfaces[5].first_interface);
+}
+
+TEST_F(UsbDescriptorsTest, CorruptInterfaceAssociations) {
+  {
+    // Descriptor is too short.
+    static const uint8_t kIAD[] = {0x01};
+    UsbConfigDescriptor config(1, false, false, 0);
+    config.extra_data.assign(kIAD, kIAD + sizeof(kIAD));
+    config.AssignFirstInterfaceNumbers();
+  }
+  {
+    // Descriptor is too long.
+    static const uint8_t kIAD[] = {0x09, 0x0b, 0x00, 0x00,
+                                   0x00, 0x00, 0x00, 0x00};
+    UsbConfigDescriptor config(1, false, false, 0);
+    config.extra_data.assign(kIAD, kIAD + sizeof(kIAD));
+    config.AssignFirstInterfaceNumbers();
+  }
+}
+
 TEST_F(UsbDescriptorsTest, StringDescriptor) {
   static const uint8_t kBuffer[] = {0x1a, 0x03, 'H', 0, 'e', 0, 'l', 0, 'l', 0,
                                     'o',  0,    ' ', 0, 'w', 0, 'o', 0, 'r', 0,
                                     'l',  0,    'd', 0, '!', 0};
   base::string16 string;
   ASSERT_TRUE(ParseUsbStringDescriptor(
       std::vector<uint8_t>(kBuffer, kBuffer + sizeof(kBuffer)), &string));
   EXPECT_EQ(base::ASCIIToUTF16("Hello world!"), string);
 }
 
@@ skipping 81 matching lines @@
                               _, _, _))
       .WillOnce(InvokeCallback(kStringDescriptor3, sizeof(kStringDescriptor3)));
 
   ReadUsbStringDescriptors(device_handle, std::move(string_map),
                            base::Bind(&ExpectStringDescriptors));
 }
 
 }  // namespace
 
 }  // namespace device