Integrate WebUSB with Feature Policy

device/usb/mojo/device_impl_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 "device/usb/mojo/device_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 428 matching lines @@
   mock_device().NotifyDeviceRemoved();
   loop.Run();
 }
 
 TEST_F(USBDeviceImplTest, Open) {
   UsbDevicePtr device = GetMockDeviceProxy();
 
   EXPECT_FALSE(is_device_open());
 
   EXPECT_CALL(mock_device(), Open(_));
+  EXPECT_CALL(permission_provider(), IncrementConnectionCount());
 
   {
     base::RunLoop loop;
     device->Open(base::Bind(&ExpectOpenAndThen, mojom::UsbOpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   {
     base::RunLoop loop;
     device->Open(base::Bind(&ExpectOpenAndThen,
                             mojom::UsbOpenDeviceError::ALREADY_OPEN,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
+  EXPECT_CALL(permission_provider(), DecrementConnectionCount());
 }
 
 TEST_F(USBDeviceImplTest, Close) {
   UsbDevicePtr device = GetMockDeviceProxy();
 
   EXPECT_FALSE(is_device_open());
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
@@ skipping 20 matching lines @@
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
     device->Open(base::Bind(&ExpectOpenAndThen, mojom::UsbOpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), SetConfiguration(42, _));
-  EXPECT_CALL(permission_provider(), HasConfigurationPermission(42, _));
 
   {
     // SetConfiguration should fail because 42 is not a valid mock
     // configuration.
     base::RunLoop loop;
     device->SetConfiguration(
         42, base::Bind(&ExpectResultAndThen, false, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 TEST_F(USBDeviceImplTest, SetValidConfiguration) {
   UsbDevicePtr device = GetMockDeviceProxy();
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
     device->Open(base::Bind(&ExpectOpenAndThen, mojom::UsbOpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), SetConfiguration(42, _));
-  EXPECT_CALL(permission_provider(), HasConfigurationPermission(42, _));
 
   AddMockConfig(ConfigBuilder(42));
 
   {
     // SetConfiguration should succeed because 42 is a valid mock configuration.
     base::RunLoop loop;
     device->SetConfiguration(
         42, base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
     loop.Run();
   }
@@ skipping 47 matching lines @@
     base::RunLoop loop;
     device->Open(base::Bind(&ExpectOpenAndThen, mojom::UsbOpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   // Now add a mock interface #1.
   AddMockConfig(ConfigBuilder(1).AddInterface(1, 0, 1, 2, 3));
 
   EXPECT_CALL(mock_handle(), SetConfiguration(1, _));
-  EXPECT_CALL(permission_provider(), HasConfigurationPermission(1, _));
 
   {
     base::RunLoop loop;
     device->SetConfiguration(
         1, base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
     loop.Run();
   }
 
   {
     // Try to claim an invalid interface and expect failure.
     base::RunLoop loop;
     device->ClaimInterface(
         2, base::Bind(&ExpectResultAndThen, false, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), ClaimInterface(1, _));
-  EXPECT_CALL(permission_provider(), HasFunctionPermission(1, 1, _));
 
   {
     base::RunLoop loop;
     device->ClaimInterface(
         1, base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), ReleaseInterface(2, _));
 
@@ skipping 64 matching lines @@
   {
     base::RunLoop loop;
     device->Open(base::Bind(&ExpectOpenAndThen, mojom::UsbOpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   AddMockConfig(ConfigBuilder(1).AddInterface(7, 0, 1, 2, 3));
 
   EXPECT_CALL(mock_handle(), SetConfiguration(1, _));
-  EXPECT_CALL(permission_provider(), HasConfigurationPermission(1, _));
 
   {
     base::RunLoop loop;
     device->SetConfiguration(
         1, base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
     loop.Run();
   }
 
   std::vector<uint8_t> fake_data;
   fake_data.push_back(41);
   fake_data.push_back(42);
   fake_data.push_back(43);
 
   AddMockInboundData(fake_data);
 
   EXPECT_CALL(mock_handle(),
               ControlTransfer(UsbTransferDirection::INBOUND,
                               UsbControlTransferType::STANDARD,
                               UsbControlTransferRecipient::DEVICE, 5, 6, 7, _,
                               _, 0, _));
-  EXPECT_CALL(permission_provider(), HasConfigurationPermission(1, _));
 
   {
     auto params = mojom::UsbControlTransferParams::New();
     params->type = UsbControlTransferType::STANDARD;
     params->recipient = UsbControlTransferRecipient::DEVICE;
     params->request = 5;
     params->value = 6;
     params->index = 7;
     base::RunLoop loop;
     device->ControlTransferIn(std::move(params),
                               static_cast<uint32_t>(fake_data.size()), 0,
                               base::Bind(&ExpectTransferInAndThen,
                                          mojom::UsbTransferStatus::COMPLETED,
                                          fake_data, loop.QuitClosure()));
     loop.Run();
   }
 
   AddMockOutboundData(fake_data);
 
   EXPECT_CALL(mock_handle(),
               ControlTransfer(UsbTransferDirection::OUTBOUND,
                               UsbControlTransferType::STANDARD,
                               UsbControlTransferRecipient::INTERFACE, 5, 6, 7,
                               _, _, 0, _));
-  EXPECT_CALL(permission_provider(), HasFunctionPermission(7, 1, _));
 
   {
     auto params = mojom::UsbControlTransferParams::New();
     params->type = UsbControlTransferType::STANDARD;
     params->recipient = UsbControlTransferRecipient::INTERFACE;
     params->request = 5;
     params->value = 6;
     params->index = 7;
     base::RunLoop loop;
     device->ControlTransferOut(
@@ skipping 118 matching lines @@
         base::Bind(&ExpectPacketsInAndThen, fake_inbound_data,
                    expected_transferred_lengths, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 }  // namespace usb
 }  // namespace device