Allow interfaceClass USB device permissions

extensions/common/permissions/usb_device_permission_unittest.cc

 // Copyright (c) 2013 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 <memory>
+
+#include "base/memory/ref_counted.h"
+#include "device/usb/mock_usb_device.h"
+#include "device/usb/usb_descriptors.h"
+#include "extensions/common/extension_builder.h"
+#include "extensions/common/features/feature_channel.h"
+#include "extensions/common/features/feature_session_type.h"
+#include "extensions/common/permissions/usb_device_permission.h"
 #include "extensions/common/permissions/usb_device_permission_data.h"
+#include "extensions/common/value_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace extensions {
 
+namespace {
+
+// ID of test USB device config to which interfaces described by
+// |interface_classes| parameter of |CreateTestUsbDevice| should be added.
+const int kUsbConfigWithInterfaces = 1;
+
+// ID of test USB device config created by |CreateTestUsbDevice| that contains
+// no interfaces.
+const int kUsbConfigWithoutInterfaces = 2;
+
+scoped_refptr<device::MockUsbDevice> CreateTestUsbDevice(
+    uint16_t vendor_id,
+    uint16_t product_id,
+    uint8_t device_class,
+    const std::vector<uint8_t> interface_classes) {
+  std::vector<device::UsbConfigDescriptor> configs;
+  configs.emplace_back(kUsbConfigWithInterfaces, false, false, 0);
+  configs.emplace_back(kUsbConfigWithoutInterfaces, false, false, 0);
+
+  for (size_t i = 0; i < interface_classes.size(); ++i)
+    configs[0].interfaces.emplace_back(i, 0, interface_classes[i], 255, 255);
+
+  return new device::MockUsbDevice(vendor_id, product_id, device_class,
+                                   configs);
+}
+
+scoped_refptr<const Extension> CreateTestApp(
+    std::unique_ptr<base::Value> usb_device_permission) {
+  return ExtensionBuilder()
+      .SetManifest(
+          DictionaryBuilder()
+              .Set("name", "test app")
+              .Set("version", "1")
+              .Set("app",
+                   DictionaryBuilder()
+                       .Set("background",
+                            DictionaryBuilder()
+                                .Set("scripts", ListBuilder()
+                                                    .Append("background.js")
+                                                    .Build())
+                                .Build())
+                       .Build())
+              .Set("permissions",
+                   ListBuilder()
+                       .Append("usb")
+                       .Append(
+                           DictionaryBuilder()
+                               .Set("usbDevice", ListBuilder()
+                                                     .Append(std::move(
+                                                         usb_device_permission))
+                                                     .Build())
+                               .Build())
+                       .Build())
+              .Build())
+      .Build();
+}
+
+}  // namespace
+
 TEST(USBDevicePermissionTest, PermissionDataOrder) {
-  EXPECT_LT(UsbDevicePermissionData(0x02ad, 0x138c, -1),
-            UsbDevicePermissionData(0x02ad, 0x138d, -1));
-  ASSERT_LT(UsbDevicePermissionData(0x02ad, 0x138d, -1),
-            UsbDevicePermissionData(0x02ae, 0x138c, -1));
-  EXPECT_LT(UsbDevicePermissionData(0x02ad, 0x138c, -1),
-            UsbDevicePermissionData(0x02ad, 0x138c, 0));
+  EXPECT_LT(UsbDevicePermissionData(0x02ad, 0x138c, -1, -1),
+            UsbDevicePermissionData(0x02ad, 0x138d, -1, -1));
+  ASSERT_LT(UsbDevicePermissionData(0x02ad, 0x138d, -1, -1),
+            UsbDevicePermissionData(0x02ae, 0x138c, -1, -1));
+  EXPECT_LT(UsbDevicePermissionData(0x02ad, 0x138c, 1, 3),
+            UsbDevicePermissionData(0x02ad, 0x138c, 2, 2));
+  EXPECT_LT(UsbDevicePermissionData(0x02ad, 0x138c, 1, 2),
+            UsbDevicePermissionData(0x02ad, 0x138c, 1, 3));
+}
+
+TEST(USBDevicePermissionTest, CheckVendorAndProductId) {
+  std::unique_ptr<base::Value> permission_data_value =
+      DictionaryBuilder()
+          .Set("vendorId", 0x02ad)
+          .Set("productId", 0x138c)
+          .Build();
+
+  UsbDevicePermissionData permission_data;
+  ASSERT_TRUE(permission_data.FromValue(permission_data_value.get()));
+
+  scoped_refptr<const Extension> app =
+      CreateTestApp(std::move(permission_data_value));
+
+  {
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass(
+            app.get(), 0x02ad, 0x138c,
+            UsbDevicePermissionData::SPECIAL_VALUE_UNSPECIFIED);
+
+    EXPECT_TRUE(permission_data.Check(param.get()));
+  }
+
+  {
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass(
+            app.get(), 0x138c, 0x02ad,
+            UsbDevicePermissionData::SPECIAL_VALUE_UNSPECIFIED);
+
+    EXPECT_FALSE(permission_data.Check(param.get()));
+  }
+
+  {
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass(
+            app.get(), 0x02ad, 0x138c, 3);
+
+    EXPECT_FALSE(permission_data.Check(param.get()));
+  }
+}
+
+TEST(USBDevicePermissionTest, CheckInterfaceId) {
+  std::unique_ptr<base::Value> permission_data_value =
+      DictionaryBuilder()
+          .Set("vendorId", 0x02ad)
+          .Set("productId", 0x138c)
+          .Set("interfaceId", 3)
+          .Build();
+  UsbDevicePermissionData permission_data;
+  ASSERT_TRUE(permission_data.FromValue(permission_data_value.get()));
+
+  scoped_refptr<const Extension> app =
+      CreateTestApp(std::move(permission_data_value));
+  {
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass(
+            app.get(), 0x02ad, 0x138c, 3);
+
+    EXPECT_TRUE(permission_data.Check(param.get()));
+  }
+
+  {
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass(
+            app.get(), 0x02ad, 0x138c, 2);
+
+    EXPECT_FALSE(permission_data.Check(param.get()));
+  }
+
+  {
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass(
+            app.get(), 0x02ad, 0x138c,
+            UsbDevicePermissionData::SPECIAL_VALUE_UNSPECIFIED);
+
+    EXPECT_TRUE(permission_data.Check(param.get()));
+  }
+}
+
+TEST(USBDevicePermissionTest, InterfaceClass) {
+  std::unique_ptr<base::Value> permission_data_value =
+      DictionaryBuilder().Set("interfaceClass", 3).Build();
+  UsbDevicePermissionData permission_data;
+  EXPECT_TRUE(permission_data.FromValue(permission_data_value.get()));
+
+  scoped_refptr<const Extension> app =
+      CreateTestApp(std::move(permission_data_value));
+
+  {
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass(
+            app.get(), 0x02ad, 0x138c,
+            UsbDevicePermissionData::SPECIAL_VALUE_UNSPECIFIED);
+
+    EXPECT_FALSE(permission_data.Check(param.get()));
+  }
+
+  {
+    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type_(
+        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
+    ScopedCurrentChannel channel(version_info::Channel::DEV);
+
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass(
+            app.get(), 0x02ad, 0x138c,
+            UsbDevicePermissionData::SPECIAL_VALUE_UNSPECIFIED);
+
+    EXPECT_TRUE(permission_data.Check(param.get()));

[Reilly Grant (use Gerrit), 2016/10/25 20:44:03]

Can you add a comment explaining why this is expected to be true? I can see that
it has to do with the implementation of findDevices but it's non-intuitive.

[tbarzic, 2016/10/25 21:17:08]

Done.

Added more detailed comment to ForDeviceWithAnyInterfaceClass (since I agree
this is a bit non-intuitive)

+  }
+}
+
+TEST(USBDevicePermissionTest, InterfaceClassWithVendorId) {
+  std::unique_ptr<base::Value> permission_data_value =
+      DictionaryBuilder()
+          .Set("vendorId", 0x02ad)
+          .Set("interfaceClass", 3)
+          .Build();
+  UsbDevicePermissionData permission_data;
+  EXPECT_TRUE(permission_data.FromValue(permission_data_value.get()));
+
+  scoped_refptr<const Extension> app =
+      CreateTestApp(std::move(permission_data_value));
+
+  {
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass(
+            app.get(), 0x02ad, 0x138c,
+            UsbDevicePermissionData::SPECIAL_VALUE_UNSPECIFIED);
+
+    EXPECT_FALSE(permission_data.Check(param.get()));
+  }
+
+  {
+    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type_(
+        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
+    ScopedCurrentChannel channel(version_info::Channel::DEV);
+
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass(
+            app.get(), 0x02ad, 0x138c,
+            UsbDevicePermissionData::SPECIAL_VALUE_UNSPECIFIED);
+
+    EXPECT_TRUE(permission_data.Check(param.get()));
+  }
+
+  {
+    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type_(
+        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
+    ScopedCurrentChannel channel(version_info::Channel::DEV);
+
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass(
+            app.get(), 0x138c, 0x138c,
+            UsbDevicePermissionData::SPECIAL_VALUE_UNSPECIFIED);
+
+    EXPECT_FALSE(permission_data.Check(param.get()));
+  }
+}
+
+TEST(USBDevicePermissionTest, CheckHidUsbAgainstInterfaceClass) {
+  std::unique_ptr<base::Value> permission_data_value =
+      DictionaryBuilder()
+          .Set("vendorId", 0x02ad)
+          .Set("interfaceClass", 3)
+          .Build();
+  UsbDevicePermissionData permission_data;
+  EXPECT_TRUE(permission_data.FromValue(permission_data_value.get()));
+
+  scoped_refptr<const Extension> app =
+      CreateTestApp(std::move(permission_data_value));
+
+  {
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForHidDevice(app.get(), 0x02ad,
+                                                      0x138c);
+
+    EXPECT_FALSE(permission_data.Check(param.get()));
+  }
+
+  {
+    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type_(
+        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
+    ScopedCurrentChannel channel(version_info::Channel::DEV);
+
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForHidDevice(app.get(), 0x02ad,
+                                                      0x138c);
+
+    EXPECT_TRUE(permission_data.Check(param.get()));
+  }
+
+  {
+    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type_(
+        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
+    ScopedCurrentChannel channel(version_info::Channel::DEV);
+
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForHidDevice(app.get(), 0x138c,
+                                                      0x138c);
+
+    EXPECT_FALSE(permission_data.Check(param.get()));
+  }
+}
+
+TEST(USBDevicePermissionTest, CheckHidUsbAgainstDeviceIds) {
+  std::unique_ptr<base::Value> permission_data_value =
+      DictionaryBuilder()
+          .Set("vendorId", 0x02ad)
+          .Set("productId", 0x138c)
+          .Build();
+  UsbDevicePermissionData permission_data;
+  EXPECT_TRUE(permission_data.FromValue(permission_data_value.get()));
+
+  scoped_refptr<const Extension> app =
+      CreateTestApp(std::move(permission_data_value));
+
+  {
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForHidDevice(app.get(), 0x02ad,
+                                                      0x138c);
+
+    EXPECT_TRUE(permission_data.Check(param.get()));
+  }
+
+  {
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForHidDevice(app.get(), 0x138c,
+                                                      0x138c);
+
+    EXPECT_FALSE(permission_data.Check(param.get()));
+  }
+}
+
+TEST(USBDevicePermissionTest, CheckDeviceAgainstDeviceIds) {
+  std::unique_ptr<base::Value> permission_data_value =
+      DictionaryBuilder()
+          .Set("vendorId", 0x02ad)
+          .Set("productId", 0x138c)
+          .Build();
+  UsbDevicePermissionData permission_data;
+  EXPECT_TRUE(permission_data.FromValue(permission_data_value.get()));
+
+  scoped_refptr<const Extension> app =
+      CreateTestApp(std::move(permission_data_value));
+
+  {
+    scoped_refptr<device::MockUsbDevice> device =
+        CreateTestUsbDevice(0x02ad, 0x138c, 0x9, std::vector<uint8_t>());
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), device.get());
+
+    EXPECT_TRUE(permission_data.Check(param.get()));
+  }
+
+  {
+    scoped_refptr<device::MockUsbDevice> device =
+        CreateTestUsbDevice(0x138c, 0x138c, 0x9, std::vector<uint8_t>());
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), device.get());
+
+    EXPECT_FALSE(permission_data.Check(param.get()));
+  }
+}
+
+TEST(USBDevicePermissionTest, CheckDeviceAgainstDeviceClass) {
+  std::unique_ptr<base::Value> permission_data_value =
+      DictionaryBuilder().Set("interfaceClass", 0x9).Build();
+  UsbDevicePermissionData permission_data;
+  EXPECT_TRUE(permission_data.FromValue(permission_data_value.get()));
+
+  scoped_refptr<const Extension> app =
+      CreateTestApp(std::move(permission_data_value));
+
+  {
+    scoped_refptr<device::MockUsbDevice> device =
+        CreateTestUsbDevice(0x02ad, 0x138c, 0x9, std::vector<uint8_t>());
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), device.get());
+
+    EXPECT_FALSE(permission_data.Check(param.get()));
+  }
+
+  {
+    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type_(
+        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
+    ScopedCurrentChannel channel(version_info::Channel::DEV);
+
+    scoped_refptr<device::MockUsbDevice> device =
+        CreateTestUsbDevice(0x02ad, 0x138c, 0x9, std::vector<uint8_t>());
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), device.get());
+
+    EXPECT_TRUE(permission_data.Check(param.get()));
+  }
+  {
+    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type_(
+        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
+    ScopedCurrentChannel channel(version_info::Channel::DEV);
+
+    scoped_refptr<device::MockUsbDevice> device =
+        CreateTestUsbDevice(0x02ad, 0x138c, 0x3, std::vector<uint8_t>());
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), device.get());
+
+    EXPECT_FALSE(permission_data.Check(param.get()));
+  }
+}
+
+TEST(USBDevicePermissionTest, IgnoreNullDeviceClass) {
+  std::unique_ptr<base::Value> permission_data_value =
+      DictionaryBuilder().Set("interfaceClass", 0).Build();
+  UsbDevicePermissionData permission_data;
+  EXPECT_TRUE(permission_data.FromValue(permission_data_value.get()));
+
+  scoped_refptr<const Extension> app =
+      CreateTestApp(std::move(permission_data_value));
+
+  {
+    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type_(
+        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
+    ScopedCurrentChannel channel(version_info::Channel::DEV);
+
+    scoped_refptr<device::MockUsbDevice> device =
+        CreateTestUsbDevice(0x02ad, 0x138c, 0, std::vector<uint8_t>());
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), device.get());
+
+    EXPECT_FALSE(permission_data.Check(param.get()));
+  }
+}
+
+TEST(USBDevicePermissionTest, CheckDeviceAgainstInterfaceClass) {
+  std::unique_ptr<base::Value> permission_data_value =
+      DictionaryBuilder().Set("interfaceClass", 0x3).Build();
+  UsbDevicePermissionData permission_data;
+  EXPECT_TRUE(permission_data.FromValue(permission_data_value.get()));
+
+  scoped_refptr<const Extension> app =
+      CreateTestApp(std::move(permission_data_value));
+
+  {
+    scoped_refptr<device::MockUsbDevice> device =
+        CreateTestUsbDevice(0x02ad, 0x138c, 0, {2, 3});
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), device.get());
+
+    EXPECT_FALSE(permission_data.Check(param.get()));
+  }
+
+  {
+    // Interface should match inactive configuration when none of configurations
+    // is active.
+    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type_(
+        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
+    ScopedCurrentChannel channel(version_info::Channel::DEV);
+
+    scoped_refptr<device::MockUsbDevice> device =
+        CreateTestUsbDevice(0x02ad, 0x138c, 0, {2, 3});
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), device.get());
+
+    EXPECT_TRUE(permission_data.Check(param.get()));
+  }
+
+  {
+    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type_(
+        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
+    ScopedCurrentChannel channel(version_info::Channel::DEV);
+
+    scoped_refptr<device::MockUsbDevice> device =
+        CreateTestUsbDevice(0x02ad, 0x138c, 0, {2, 3});
+    device->ActiveConfigurationChanged(kUsbConfigWithInterfaces);
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), device.get());
+
+    EXPECT_TRUE(permission_data.Check(param.get()));
+  }
+
+  {
+    // Interface should match inactive configuration when another configuration
+    // is active.
+    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type_(
+        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
+    ScopedCurrentChannel channel(version_info::Channel::DEV);
+
+    scoped_refptr<device::MockUsbDevice> device =
+        CreateTestUsbDevice(0x02ad, 0x138c, 0, {2, 3});
+    device->ActiveConfigurationChanged(kUsbConfigWithoutInterfaces);
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), device.get());
+
+    EXPECT_TRUE(permission_data.Check(param.get()));
+  }
+
+  {
+    std::unique_ptr<base::AutoReset<FeatureSessionType>> scoped_session_type_(
+        ScopedCurrentFeatureSessionType(FeatureSessionType::KIOSK));
+    ScopedCurrentChannel channel(version_info::Channel::DEV);
+
+    scoped_refptr<device::MockUsbDevice> device =
+        CreateTestUsbDevice(0x02ad, 0x138c, 0, {4, 5});
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), device.get());
+
+    EXPECT_FALSE(permission_data.Check(param.get()));
+  }
+}
+
+TEST(USBDevicePermissionTest, CheckDeviceAndInterfaceId) {
+  std::unique_ptr<base::Value> permission_data_value =
+      DictionaryBuilder()
+          .Set("vendorId", 0x02ad)
+          .Set("productId", 0x138c)
+          .Set("interfaceId", 3)
+          .Build();
+  UsbDevicePermissionData permission_data;
+  EXPECT_TRUE(permission_data.FromValue(permission_data_value.get()));
+
+  scoped_refptr<const Extension> app =
+      CreateTestApp(std::move(permission_data_value));
+
+  {
+    scoped_refptr<device::MockUsbDevice> device =
+        CreateTestUsbDevice(0x02ad, 0x138c, 0, std::vector<uint8_t>());
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForUsbDeviceAndInterface(
+            app.get(), device.get(), 3);
+
+    EXPECT_TRUE(permission_data.Check(param.get()));
+  }
+
+  {
+    scoped_refptr<device::MockUsbDevice> device =
+        CreateTestUsbDevice(0x02ad, 0x138c, 0, std::vector<uint8_t>());
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForUsbDeviceAndInterface(
+            app.get(), device.get(), 2);
+
+    EXPECT_FALSE(permission_data.Check(param.get()));
+  }
+}
+
+TEST(USBDevicePermissionTest,
+     CheckDeviceAndInterfaceIDAgainstMissingInterfaceId) {
+  std::unique_ptr<base::Value> permission_data_value =
+      DictionaryBuilder()
+          .Set("vendorId", 0x02ad)
+          .Set("productId", 0x138c)
+          .Build();
+  UsbDevicePermissionData permission_data;
+  EXPECT_TRUE(permission_data.FromValue(permission_data_value.get()));
+
+  scoped_refptr<const Extension> app =
+      CreateTestApp(std::move(permission_data_value));
+
+  {
+    scoped_refptr<device::MockUsbDevice> device =
+        CreateTestUsbDevice(0x02ad, 0x138c, 0, std::vector<uint8_t>());
+    std::unique_ptr<UsbDevicePermission::CheckParam> param =
+        UsbDevicePermission::CheckParam::ForUsbDeviceAndInterface(
+            app.get(), device.get(), 3);
+
+    EXPECT_FALSE(permission_data.Check(param.get()));
+  }
+}
+
+TEST(USBDevicePermissionTest, InvalidPermission_NoVendorId) {
+  std::unique_ptr<base::Value> permission_data_value =
+      DictionaryBuilder()
+          .Set("productId", 0x138c)
+          .Set("interfaceClass", 3)
+          .Build();
+  UsbDevicePermissionData permission_data;
+  ASSERT_FALSE(permission_data.FromValue(permission_data_value.get()));
+}
+
+TEST(USBDevicePermissionTest, InvalidPermission_OnlyVendorId) {
+  std::unique_ptr<base::Value> permission_data_value =
+      DictionaryBuilder().Set("vendorId", 0x02ad).Build();
+  UsbDevicePermissionData permission_data;
+  ASSERT_FALSE(permission_data.FromValue(permission_data_value.get()));
+}
+
+TEST(USBDevicePermissionTest, InvalidPermission_NoProductIdWithInterfaceId) {
+  std::unique_ptr<base::Value> permission_data_value =
+      DictionaryBuilder().Set("vendorId", 0x02ad).Set("interfaceId", 3).Build();
+  UsbDevicePermissionData permission_data;
+  ASSERT_FALSE(permission_data.FromValue(permission_data_value.get()));
+}
+
+TEST(USBDevicePermissionTest, RejectInterfaceIdIfInterfaceClassPresent) {
+  std::unique_ptr<base::Value> permission_data_value =
+      DictionaryBuilder()
+          .Set("vendorId", 0x02ad)
+          .Set("productId", 0x128c)
+          .Set("interfaceId", 3)
+          .Set("interfaceClass", 7)
+          .Build();
+  UsbDevicePermissionData permission_data;
+  ASSERT_FALSE(permission_data.FromValue(permission_data_value.get()));
 }
 
 }  // namespace extensions