| // Copyright 2013 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <memory> |
| #include <utility> |
| |
| #include "base/memory/ref_counted.h" |
| #include "components/version_info/channel.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/mojom/feature_session_type.mojom.h" |
| #include "extensions/common/permissions/usb_device_permission.h" |
| #include "extensions/common/permissions/usb_device_permission_data.h" |
| #include "services/device/public/cpp/test/fake_usb_device_info.h" |
| #include "services/device/public/mojom/usb_device.mojom.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::FakeUsbDeviceInfo> CreateTestUsbDevice( |
| uint16_t vendor_id, |
| uint16_t product_id, |
| uint8_t device_class, |
| const std::vector<uint8_t> interface_classes) { |
| std::vector<device::mojom::UsbConfigurationInfoPtr> configs; |
| auto config_1 = device::mojom::UsbConfigurationInfo::New(); |
| config_1->configuration_value = kUsbConfigWithInterfaces; |
| configs.push_back(std::move(config_1)); |
| |
| auto config_2 = device::mojom::UsbConfigurationInfo::New(); |
| config_2->configuration_value = kUsbConfigWithoutInterfaces; |
| configs.push_back(std::move(config_2)); |
| |
| for (size_t i = 0; i < interface_classes.size(); ++i) { |
| auto alternate = device::mojom::UsbAlternateInterfaceInfo::New(); |
| alternate->alternate_setting = 0; |
| alternate->class_code = interface_classes[i]; |
| alternate->subclass_code = 255; |
| alternate->protocol_code = 255; |
| |
| auto interface = device::mojom::UsbInterfaceInfo::New(); |
| interface->interface_number = i; |
| interface->alternates.push_back(std::move(std::move(alternate))); |
| |
| configs[0]->interfaces.push_back(std::move(interface)); |
| } |
| |
| return new device::FakeUsbDeviceInfo(vendor_id, product_id, device_class, |
| std::move(configs)); |
| } |
| |
| scoped_refptr<const Extension> CreateTestApp( |
| base::Value usb_device_permission) { |
| return ExtensionBuilder() |
| .SetManifest( |
| base::Value::Dict() |
| .Set("name", "test app") |
| .Set("version", "1") |
| .Set("app", base::Value::Dict().Set( |
| "background", |
| base::Value::Dict().Set( |
| "scripts", |
| base::Value::List().Append("background.js")))) |
| .Set("permissions", |
| base::Value::List().Append("usb").Append( |
| base::Value::Dict().Set( |
| "usbDevices", base::Value::List().Append(std::move( |
| usb_device_permission)))))) |
| .Build(); |
| } |
| |
| } // namespace |
| |
| TEST(USBDevicePermissionTest, PermissionDataOrder) { |
| 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) { |
| base::Value permission_data_value( |
| base::Value::Dict().Set("vendorId", 0x02ad).Set("productId", 0x138c)); |
| |
| UsbDevicePermissionData permission_data; |
| ASSERT_TRUE(permission_data.FromValue(&permission_data_value)); |
| |
| 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) { |
| base::Value permission_data_value(base::Value::Dict() |
| .Set("vendorId", 0x02ad) |
| .Set("productId", 0x138c) |
| .Set("interfaceId", 3)); |
| UsbDevicePermissionData permission_data; |
| ASSERT_TRUE(permission_data.FromValue(&permission_data_value)); |
| |
| 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) { |
| base::Value permission_data_value( |
| base::Value::Dict().Set("interfaceClass", 3)); |
| UsbDevicePermissionData permission_data; |
| EXPECT_TRUE(permission_data.FromValue(&permission_data_value)); |
| |
| 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); |
| |
| // Interface class permission should be ignored when not in kiosk session. |
| EXPECT_FALSE(permission_data.Check(param.get())); |
| } |
| |
| { |
| std::unique_ptr<base::AutoReset<mojom::FeatureSessionType>> |
| scoped_session_type( |
| ScopedCurrentFeatureSessionType(mojom::FeatureSessionType::kKiosk)); |
| ScopedCurrentChannel channel(version_info::Channel::DEV); |
| |
| std::unique_ptr<UsbDevicePermission::CheckParam> param = |
| UsbDevicePermission::CheckParam::ForDeviceWithAnyInterfaceClass( |
| app.get(), 0x02ad, 0x138c, |
| UsbDevicePermissionData::SPECIAL_VALUE_UNSPECIFIED); |
| |
| // |ForDeviceWithAnyInterfaceClass| creates check param that matches any |
| // interfaceClass permission property - needed in cases where set of |
| // interface classes supported by a USB device is not known. |
| // In this case, there is a usbDevice permisison with only interfaceClass |
| // set, so the param is accepted. |
| EXPECT_TRUE(permission_data.Check(param.get())); |
| } |
| } |
| |
| TEST(USBDevicePermissionTest, InterfaceClassWithVendorId) { |
| base::Value permission_data_value( |
| base::Value::Dict().Set("vendorId", 0x02ad).Set("interfaceClass", 3)); |
| UsbDevicePermissionData permission_data; |
| EXPECT_TRUE(permission_data.FromValue(&permission_data_value)); |
| |
| 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<mojom::FeatureSessionType>> |
| scoped_session_type( |
| ScopedCurrentFeatureSessionType(mojom::FeatureSessionType::kKiosk)); |
| 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<mojom::FeatureSessionType>> |
| scoped_session_type( |
| ScopedCurrentFeatureSessionType(mojom::FeatureSessionType::kKiosk)); |
| 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) { |
| base::Value permission_data_value( |
| base::Value::Dict().Set("vendorId", 0x02ad).Set("interfaceClass", 3)); |
| UsbDevicePermissionData permission_data; |
| EXPECT_TRUE(permission_data.FromValue(&permission_data_value)); |
| |
| 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<mojom::FeatureSessionType>> |
| scoped_session_type( |
| ScopedCurrentFeatureSessionType(mojom::FeatureSessionType::kKiosk)); |
| 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<mojom::FeatureSessionType>> |
| scoped_session_type( |
| ScopedCurrentFeatureSessionType(mojom::FeatureSessionType::kKiosk)); |
| 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) { |
| base::Value permission_data_value( |
| base::Value::Dict().Set("vendorId", 0x02ad).Set("productId", 0x138c)); |
| UsbDevicePermissionData permission_data; |
| EXPECT_TRUE(permission_data.FromValue(&permission_data_value)); |
| |
| 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) { |
| base::Value permission_data_value( |
| base::Value::Dict().Set("vendorId", 0x02ad).Set("productId", 0x138c)); |
| UsbDevicePermissionData permission_data; |
| EXPECT_TRUE(permission_data.FromValue(&permission_data_value)); |
| |
| scoped_refptr<const Extension> app = |
| CreateTestApp(std::move(permission_data_value)); |
| |
| { |
| scoped_refptr<device::FakeUsbDeviceInfo> device = |
| CreateTestUsbDevice(0x02ad, 0x138c, 0x9, std::vector<uint8_t>()); |
| std::unique_ptr<UsbDevicePermission::CheckParam> param = |
| UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), |
| device->GetDeviceInfo()); |
| |
| EXPECT_TRUE(permission_data.Check(param.get())); |
| } |
| |
| { |
| scoped_refptr<device::FakeUsbDeviceInfo> device = |
| CreateTestUsbDevice(0x138c, 0x138c, 0x9, std::vector<uint8_t>()); |
| std::unique_ptr<UsbDevicePermission::CheckParam> param = |
| UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), |
| device->GetDeviceInfo()); |
| |
| EXPECT_FALSE(permission_data.Check(param.get())); |
| } |
| } |
| |
| TEST(USBDevicePermissionTest, CheckDeviceAgainstDeviceClass) { |
| base::Value permission_data_value( |
| base::Value::Dict().Set("interfaceClass", 0x9)); |
| UsbDevicePermissionData permission_data; |
| EXPECT_TRUE(permission_data.FromValue(&permission_data_value)); |
| |
| scoped_refptr<const Extension> app = |
| CreateTestApp(std::move(permission_data_value)); |
| |
| { |
| scoped_refptr<device::FakeUsbDeviceInfo> device = |
| CreateTestUsbDevice(0x02ad, 0x138c, 0x9, std::vector<uint8_t>()); |
| std::unique_ptr<UsbDevicePermission::CheckParam> param = |
| UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), |
| device->GetDeviceInfo()); |
| |
| EXPECT_FALSE(permission_data.Check(param.get())); |
| } |
| |
| { |
| std::unique_ptr<base::AutoReset<mojom::FeatureSessionType>> |
| scoped_session_type( |
| ScopedCurrentFeatureSessionType(mojom::FeatureSessionType::kKiosk)); |
| ScopedCurrentChannel channel(version_info::Channel::DEV); |
| |
| scoped_refptr<device::FakeUsbDeviceInfo> device = |
| CreateTestUsbDevice(0x02ad, 0x138c, 0x9, std::vector<uint8_t>()); |
| std::unique_ptr<UsbDevicePermission::CheckParam> param = |
| UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), |
| device->GetDeviceInfo()); |
| |
| EXPECT_TRUE(permission_data.Check(param.get())); |
| } |
| { |
| std::unique_ptr<base::AutoReset<mojom::FeatureSessionType>> |
| scoped_session_type( |
| ScopedCurrentFeatureSessionType(mojom::FeatureSessionType::kKiosk)); |
| ScopedCurrentChannel channel(version_info::Channel::DEV); |
| |
| scoped_refptr<device::FakeUsbDeviceInfo> device = |
| CreateTestUsbDevice(0x02ad, 0x138c, 0x3, std::vector<uint8_t>()); |
| std::unique_ptr<UsbDevicePermission::CheckParam> param = |
| UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), |
| device->GetDeviceInfo()); |
| |
| EXPECT_FALSE(permission_data.Check(param.get())); |
| } |
| } |
| |
| TEST(USBDevicePermissionTest, IgnoreNullDeviceClass) { |
| base::Value permission_data_value( |
| base::Value::Dict().Set("interfaceClass", 0)); |
| UsbDevicePermissionData permission_data; |
| EXPECT_TRUE(permission_data.FromValue(&permission_data_value)); |
| |
| scoped_refptr<const Extension> app = |
| CreateTestApp(std::move(permission_data_value)); |
| |
| { |
| std::unique_ptr<base::AutoReset<mojom::FeatureSessionType>> |
| scoped_session_type( |
| ScopedCurrentFeatureSessionType(mojom::FeatureSessionType::kKiosk)); |
| ScopedCurrentChannel channel(version_info::Channel::DEV); |
| |
| scoped_refptr<device::FakeUsbDeviceInfo> device = |
| CreateTestUsbDevice(0x02ad, 0x138c, 0, std::vector<uint8_t>()); |
| std::unique_ptr<UsbDevicePermission::CheckParam> param = |
| UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), |
| device->GetDeviceInfo()); |
| |
| EXPECT_FALSE(permission_data.Check(param.get())); |
| } |
| } |
| |
| TEST(USBDevicePermissionTest, CheckDeviceAgainstInterfaceClass) { |
| base::Value permission_data_value( |
| base::Value::Dict().Set("interfaceClass", 0x3)); |
| UsbDevicePermissionData permission_data; |
| EXPECT_TRUE(permission_data.FromValue(&permission_data_value)); |
| |
| scoped_refptr<const Extension> app = |
| CreateTestApp(std::move(permission_data_value)); |
| |
| { |
| scoped_refptr<device::FakeUsbDeviceInfo> device = |
| CreateTestUsbDevice(0x02ad, 0x138c, 0, {2, 3}); |
| std::unique_ptr<UsbDevicePermission::CheckParam> param = |
| UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), |
| device->GetDeviceInfo()); |
| |
| EXPECT_FALSE(permission_data.Check(param.get())); |
| } |
| |
| { |
| // Interface should match inactive configuration when none of configurations |
| // is active. |
| std::unique_ptr<base::AutoReset<mojom::FeatureSessionType>> |
| scoped_session_type( |
| ScopedCurrentFeatureSessionType(mojom::FeatureSessionType::kKiosk)); |
| ScopedCurrentChannel channel(version_info::Channel::DEV); |
| |
| scoped_refptr<device::FakeUsbDeviceInfo> device = |
| CreateTestUsbDevice(0x02ad, 0x138c, 0, {2, 3}); |
| std::unique_ptr<UsbDevicePermission::CheckParam> param = |
| UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), |
| device->GetDeviceInfo()); |
| |
| EXPECT_TRUE(permission_data.Check(param.get())); |
| } |
| |
| { |
| std::unique_ptr<base::AutoReset<mojom::FeatureSessionType>> |
| scoped_session_type( |
| ScopedCurrentFeatureSessionType(mojom::FeatureSessionType::kKiosk)); |
| ScopedCurrentChannel channel(version_info::Channel::DEV); |
| |
| scoped_refptr<device::FakeUsbDeviceInfo> device = |
| CreateTestUsbDevice(0x02ad, 0x138c, 0, {2, 3}); |
| device->SetActiveConfig(kUsbConfigWithInterfaces); |
| std::unique_ptr<UsbDevicePermission::CheckParam> param = |
| UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), |
| device->GetDeviceInfo()); |
| |
| EXPECT_TRUE(permission_data.Check(param.get())); |
| } |
| |
| { |
| // Interface should match inactive configuration when another configuration |
| // is active. |
| std::unique_ptr<base::AutoReset<mojom::FeatureSessionType>> |
| scoped_session_type( |
| ScopedCurrentFeatureSessionType(mojom::FeatureSessionType::kKiosk)); |
| ScopedCurrentChannel channel(version_info::Channel::DEV); |
| |
| scoped_refptr<device::FakeUsbDeviceInfo> device = |
| CreateTestUsbDevice(0x02ad, 0x138c, 0, {2, 3}); |
| device->SetActiveConfig(kUsbConfigWithoutInterfaces); |
| std::unique_ptr<UsbDevicePermission::CheckParam> param = |
| UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), |
| device->GetDeviceInfo()); |
| |
| EXPECT_TRUE(permission_data.Check(param.get())); |
| } |
| |
| { |
| std::unique_ptr<base::AutoReset<mojom::FeatureSessionType>> |
| scoped_session_type( |
| ScopedCurrentFeatureSessionType(mojom::FeatureSessionType::kKiosk)); |
| ScopedCurrentChannel channel(version_info::Channel::DEV); |
| |
| scoped_refptr<device::FakeUsbDeviceInfo> device = |
| CreateTestUsbDevice(0x02ad, 0x138c, 0, {4, 5}); |
| std::unique_ptr<UsbDevicePermission::CheckParam> param = |
| UsbDevicePermission::CheckParam::ForUsbDevice(app.get(), |
| device->GetDeviceInfo()); |
| |
| EXPECT_FALSE(permission_data.Check(param.get())); |
| } |
| } |
| |
| TEST(USBDevicePermissionTest, CheckDeviceAndInterfaceId) { |
| base::Value permission_data_value(base::Value::Dict() |
| .Set("vendorId", 0x02ad) |
| .Set("productId", 0x138c) |
| .Set("interfaceId", 3)); |
| UsbDevicePermissionData permission_data; |
| EXPECT_TRUE(permission_data.FromValue(&permission_data_value)); |
| |
| scoped_refptr<const Extension> app = |
| CreateTestApp(std::move(permission_data_value)); |
| |
| { |
| scoped_refptr<device::FakeUsbDeviceInfo> device = |
| CreateTestUsbDevice(0x02ad, 0x138c, 0, std::vector<uint8_t>()); |
| std::unique_ptr<UsbDevicePermission::CheckParam> param = |
| UsbDevicePermission::CheckParam::ForUsbDeviceAndInterface( |
| app.get(), device->GetDeviceInfo(), 3); |
| |
| EXPECT_TRUE(permission_data.Check(param.get())); |
| } |
| |
| { |
| scoped_refptr<device::FakeUsbDeviceInfo> device = |
| CreateTestUsbDevice(0x02ad, 0x138c, 0, std::vector<uint8_t>()); |
| std::unique_ptr<UsbDevicePermission::CheckParam> param = |
| UsbDevicePermission::CheckParam::ForUsbDeviceAndInterface( |
| app.get(), device->GetDeviceInfo(), 2); |
| |
| EXPECT_FALSE(permission_data.Check(param.get())); |
| } |
| } |
| |
| TEST(USBDevicePermissionTest, |
| CheckDeviceAndInterfaceIDAgainstMissingInterfaceId) { |
| base::Value permission_data_value( |
| base::Value::Dict().Set("vendorId", 0x02ad).Set("productId", 0x138c)); |
| UsbDevicePermissionData permission_data; |
| EXPECT_TRUE(permission_data.FromValue(&permission_data_value)); |
| |
| scoped_refptr<const Extension> app = |
| CreateTestApp(std::move(permission_data_value)); |
| |
| { |
| scoped_refptr<device::FakeUsbDeviceInfo> device = |
| CreateTestUsbDevice(0x02ad, 0x138c, 0, std::vector<uint8_t>()); |
| std::unique_ptr<UsbDevicePermission::CheckParam> param = |
| UsbDevicePermission::CheckParam::ForUsbDeviceAndInterface( |
| app.get(), device->GetDeviceInfo(), 3); |
| |
| EXPECT_FALSE(permission_data.Check(param.get())); |
| } |
| } |
| |
| TEST(USBDevicePermissionTest, InvalidPermission_NoVendorId) { |
| base::Value permission_data_value( |
| base::Value::Dict().Set("productId", 0x138c).Set("interfaceClass", 3)); |
| UsbDevicePermissionData permission_data; |
| ASSERT_FALSE(permission_data.FromValue(&permission_data_value)); |
| } |
| |
| TEST(USBDevicePermissionTest, InvalidPermission_OnlyVendorId) { |
| base::Value permission_data_value( |
| base::Value::Dict().Set("vendorId", 0x02ad)); |
| UsbDevicePermissionData permission_data; |
| ASSERT_FALSE(permission_data.FromValue(&permission_data_value)); |
| } |
| |
| TEST(USBDevicePermissionTest, InvalidPermission_NoProductIdWithInterfaceId) { |
| base::Value permission_data_value( |
| base::Value::Dict().Set("vendorId", 0x02ad).Set("interfaceId", 3)); |
| UsbDevicePermissionData permission_data; |
| ASSERT_FALSE(permission_data.FromValue(&permission_data_value)); |
| } |
| |
| TEST(USBDevicePermissionTest, RejectInterfaceIdIfInterfaceClassPresent) { |
| base::Value permission_data_value(base::Value::Dict() |
| .Set("vendorId", 0x02ad) |
| .Set("productId", 0x128c) |
| .Set("interfaceId", 3) |
| .Set("interfaceClass", 7)); |
| UsbDevicePermissionData permission_data; |
| ASSERT_FALSE(permission_data.FromValue(&permission_data_value)); |
| } |
| |
| } // namespace extensions |
