Use interface associations to check function permissions.

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>
 #include <numeric>
 #include <queue>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "device/usb/mock_usb_device.h"
 #include "device/usb/mock_usb_device_handle.h"
-#include "device/usb/mojo/fake_permission_provider.h"
+#include "device/usb/mojo/mock_permission_provider.h"
 #include "device/usb/mojo/type_converters.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "net/base/io_buffer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::Invoke;
 using ::testing::_;
 
 namespace device {
 namespace usb {
@@ skipping 109 matching lines @@
  public:
   USBDeviceImplTest()
       : message_loop_(new base::MessageLoop),
         is_device_open_(false),
         allow_reset_(false),
         current_config_(0) {}
 
   ~USBDeviceImplTest() override {}
 
  protected:
+  MockPermissionProvider& permission_provider() { return permission_provider_; }
   MockUsbDevice& mock_device() { return *mock_device_.get(); }
   bool is_device_open() const { return is_device_open_; }
   MockUsbDeviceHandle& mock_handle() { return *mock_handle_.get(); }
 
   void set_allow_reset(bool allow_reset) { allow_reset_ = allow_reset; }
 
   // Creates a mock device and binds a Device proxy to a Device service impl
   // wrapping the mock device.
   DevicePtr GetMockDeviceProxy(uint16_t vendor_id,
                                uint16_t product_id,
@@ skipping 269 matching lines @@
 
   std::queue<std::vector<uint8_t>> mock_inbound_data_;
   std::queue<std::vector<uint8_t>> mock_outbound_data_;
   std::queue<std::vector<UsbDeviceHandle::IsochronousPacket>>
       mock_inbound_packets_;
   std::queue<std::vector<UsbDeviceHandle::IsochronousPacket>>
       mock_outbound_packets_;
 
   std::set<uint8_t> claimed_interfaces_;
 
-  FakePermissionProvider permission_provider_;
+  MockPermissionProvider permission_provider_;
 
   DISALLOW_COPY_AND_ASSIGN(USBDeviceImplTest);
 };
 
 }  // namespace
 
 TEST_F(USBDeviceImplTest, Disconnect) {
   DevicePtr device = GetMockDeviceProxy();
 
   base::RunLoop loop;
@@ skipping 70 matching lines @@
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
     device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::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) {
   DevicePtr device = GetMockDeviceProxy();
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
     device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::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, OpenDeviceError::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();
   }
 
   EXPECT_CALL(mock_device(), GetActiveConfiguration());
-  EXPECT_CALL(mock_handle(), ClaimInterface(2, _));
 
   {
     // 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_device(), GetActiveConfiguration());
   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 65 matching lines @@
     base::RunLoop loop;
     device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   AddMockConfig(ConfigBuilder(1).AddInterface(7, 0, 1, 2, 3));
 
   EXPECT_CALL(mock_device(), GetActiveConfiguration());
   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(USB_DIRECTION_INBOUND, UsbDeviceHandle::STANDARD,
                               UsbDeviceHandle::DEVICE, 5, 6, 7, _, _, 0, _));
+  EXPECT_CALL(permission_provider(), HasConfigurationPermission(1, _));
 
   {
     auto params = ControlTransferParams::New();
     params->type = ControlTransferType::STANDARD;
     params->recipient = ControlTransferRecipient::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, TransferStatus::COMPLETED,
                    fake_data, loop.QuitClosure()));
     loop.Run();
   }
 
   AddMockOutboundData(fake_data);
 
   EXPECT_CALL(mock_device(), GetActiveConfiguration());
   EXPECT_CALL(mock_handle(),
               ControlTransfer(USB_DIRECTION_OUTBOUND, UsbDeviceHandle::STANDARD,
                               UsbDeviceHandle::INTERFACE, 5, 6, 7, _, _, 0, _));
+  EXPECT_CALL(permission_provider(), HasFunctionPermission(7, 1, _));
 
   {
     auto params = ControlTransferParams::New();
     params->type = ControlTransferType::STANDARD;
     params->recipient = ControlTransferRecipient::INTERFACE;
     params->request = 5;
     params->value = 6;
     params->index = 7;
     base::RunLoop loop;
     device->ControlTransferOut(
@@ skipping 116 matching lines @@
         base::Bind(&ExpectPacketsInAndThen, fake_inbound_data,
                    expected_transferred_lengths, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 }  // namespace usb
 }  // namespace device