Add configuration and interface permission checks to DeviceImpl.

device/devices_app/usb/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 <map>
 #include <queue>
 #include <set>
 #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/devices_app/usb/device_impl.h"
+#include "device/devices_app/usb/fake_permission_provider.h"
 #include "device/usb/mock_usb_device.h"
 #include "device/usb/mock_usb_device_handle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/mojo/src/mojo/public/cpp/bindings/interface_request.h"
 
 using ::testing::Invoke;
 using ::testing::_;
 
 namespace device {
 namespace usb {
@@ skipping 117 matching lines @@
   // wrapping the mock device.
   DevicePtr GetMockDeviceProxy(uint16_t vendor_id,
                                uint16_t product_id,
                                const std::string& manufacturer,
                                const std::string& product,
                                const std::string& serial) {
     mock_device_ =
         new MockUsbDevice(vendor_id, product_id, manufacturer, product, serial);
     mock_handle_ = new MockUsbDeviceHandle(mock_device_.get());
 
+    PermissionProviderPtr permission_provider;
+    permission_provider_.Bind(mojo::GetProxy(&permission_provider));
     DevicePtr proxy;
-    new DeviceImpl(mock_device_, mojo::GetProxy(&proxy));
+    new DeviceImpl(mock_device_, permission_provider.Pass(),
+                   mojo::GetProxy(&proxy));
 
     // Set up mock handle calls to respond based on mock device configs
     // established by the test.
     ON_CALL(mock_device(), Open(_))
         .WillByDefault(Invoke(this, &USBDeviceImplTest::OpenMockHandle));
+    ON_CALL(mock_device(), GetActiveConfiguration())
+        .WillByDefault(
+            Invoke(this, &USBDeviceImplTest::GetActiveConfiguration));
     ON_CALL(mock_handle(), Close())
         .WillByDefault(Invoke(this, &USBDeviceImplTest::CloseMockHandle));
     ON_CALL(mock_handle(), SetConfiguration(_, _))
         .WillByDefault(Invoke(this, &USBDeviceImplTest::SetConfiguration));
     ON_CALL(mock_handle(), ClaimInterface(_, _))
         .WillByDefault(Invoke(this, &USBDeviceImplTest::ClaimInterface));
     ON_CALL(mock_handle(), ReleaseInterface(_))
         .WillByDefault(Invoke(this, &USBDeviceImplTest::ReleaseInterface));
     ON_CALL(mock_handle(), SetInterfaceAlternateSetting(_, _, _))
         .WillByDefault(
@@ skipping 33 matching lines @@
     EXPECT_FALSE(is_device_open_);
     is_device_open_ = true;
     callback.Run(mock_handle_);
   }
 
   void CloseMockHandle() {
     EXPECT_TRUE(is_device_open_);
     is_device_open_ = false;
   }
 
+  const UsbConfigDescriptor* GetActiveConfiguration() {
+    if (current_config_ == 0) {
+      return nullptr;
+    } else {
+      const auto it = mock_configs_.find(current_config_);
+      EXPECT_TRUE(it != mock_configs_.end());
+      return &it->second;
+    }
+  }
+
   void SetConfiguration(uint8_t value,
                         const UsbDeviceHandle::ResultCallback& callback) {
     if (mock_configs_.find(value) != mock_configs_.end()) {
       current_config_ = value;
       callback.Run(true);
     } else {
       callback.Run(false);
     }
   }
 
@@ skipping 112 matching lines @@
   bool allow_reset_;
 
   std::map<uint8_t, UsbConfigDescriptor> mock_configs_;
   uint8_t current_config_;
 
   std::queue<std::vector<uint8_t>> mock_inbound_data_;
   std::queue<std::vector<uint8_t>> mock_outbound_data_;
 
   std::set<uint8_t> claimed_interfaces_;
 
+  FakePermissionProvider permission_provider_;
+
   DISALLOW_COPY_AND_ASSIGN(USBDeviceImplTest);
 };
 
 }  // namespace
 
 TEST_F(USBDeviceImplTest, Open) {
   DevicePtr device = GetMockDeviceProxy();
 
   EXPECT_FALSE(is_device_open());
 
@@ skipping 141 matching lines @@
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
     device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   // Now add a mock interface #1.
-  AddMockConfig(ConfigBuilder(0).AddInterface(1, 0, 1, 2, 3));
+  AddMockConfig(ConfigBuilder(1).AddInterface(1, 0, 1, 2, 3));
 
+  EXPECT_CALL(mock_handle(), SetConfiguration(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, _));
 
   {
     base::RunLoop loop;
     device->ClaimInterface(
         1, base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), ReleaseInterface(2));
@@ skipping 24 matching lines @@
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
     device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
-  AddMockConfig(ConfigBuilder(0)
+  AddMockConfig(ConfigBuilder(1)
                     .AddInterface(1, 0, 1, 2, 3)
                     .AddInterface(1, 42, 1, 2, 3)
                     .AddInterface(2, 0, 1, 2, 3));
 
   EXPECT_CALL(mock_handle(), SetInterfaceAlternateSetting(1, 42, _));
 
   {
     base::RunLoop loop;
     device->SetInterfaceAlternateSetting(
         1, 42, base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
@@ skipping 17 matching lines @@
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
     device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_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, _));
+
+  {
+    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, _));
 
   {
     auto params = ControlTransferParams::New();
     params->type = CONTROL_TRANSFER_TYPE_STANDARD;
     params->recipient = CONTROL_TRANSFER_RECIPIENT_DEVICE;
     params->request = 5;
     params->value = 6;
     params->index = 7;
     base::RunLoop loop;
     device->ControlTransferIn(
         params.Pass(), static_cast<uint32_t>(fake_data.size()), 0,
         base::Bind(&ExpectTransferInAndThen, TRANSFER_STATUS_COMPLETED,
                    fake_data, loop.QuitClosure()));
     loop.Run();
   }
 
-  AddMockConfig(ConfigBuilder(0).AddInterface(7, 0, 1, 2, 3));
   AddMockOutboundData(fake_data);
 
+  EXPECT_CALL(mock_device(), GetActiveConfiguration());
   EXPECT_CALL(mock_handle(),
               ControlTransfer(USB_DIRECTION_OUTBOUND, UsbDeviceHandle::STANDARD,
                               UsbDeviceHandle::INTERFACE, 5, 6, 7, _, _, 0, _));
 
   {
     auto params = ControlTransferParams::New();
     params->type = CONTROL_TRANSFER_TYPE_STANDARD;
     params->recipient = CONTROL_TRANSFER_RECIPIENT_INTERFACE;
     params->request = 5;
     params->value = 6;
@@ skipping 22 matching lines @@
   }
 
   std::string message1 = "say hello please";
   std::vector<uint8_t> fake_outbound_data(message1.size());
   std::copy(message1.begin(), message1.end(), fake_outbound_data.begin());
 
   std::string message2 = "hello world!";
   std::vector<uint8_t> fake_inbound_data(message2.size());
   std::copy(message2.begin(), message2.end(), fake_inbound_data.begin());
 
-  AddMockConfig(ConfigBuilder(0).AddInterface(7, 0, 1, 2, 3));
+  AddMockConfig(ConfigBuilder(1).AddInterface(7, 0, 1, 2, 3));
   AddMockOutboundData(fake_outbound_data);
   AddMockInboundData(fake_inbound_data);
 
   EXPECT_CALL(mock_handle(), GenericTransfer(USB_DIRECTION_OUTBOUND, 0x01, _,
                                              fake_outbound_data.size(), 0, _));
 
   {
     base::RunLoop loop;
     device->GenericTransferOut(
         1, mojo::Array<uint8_t>::From(fake_outbound_data), 0,
@@ skipping 32 matching lines @@
   std::string outbound_packet_data = "aaaaaaaabbbbbbbbccccccccdddddddd";
   std::vector<uint8_t> fake_outbound_packets(outbound_packet_data.size());
   std::copy(outbound_packet_data.begin(), outbound_packet_data.end(),
             fake_outbound_packets.begin());
 
   std::string inbound_packet_data = "ddddddddccccccccbbbbbbbbaaaaaaaa";
   std::vector<uint8_t> fake_inbound_packets(inbound_packet_data.size());
   std::copy(inbound_packet_data.begin(), inbound_packet_data.end(),
             fake_inbound_packets.begin());
 
-  AddMockConfig(ConfigBuilder(0).AddInterface(7, 0, 1, 2, 3));
+  AddMockConfig(ConfigBuilder(1).AddInterface(7, 0, 1, 2, 3));
   AddMockOutboundData(fake_outbound_packets);
   AddMockInboundData(fake_inbound_packets);
 
   EXPECT_CALL(mock_handle(),
               IsochronousTransfer(USB_DIRECTION_OUTBOUND, 0x01, _,
                                   fake_outbound_packets.size(), 4, 8, 0, _));
 
   {
     base::RunLoop loop;
     mojo::Array<mojo::Array<uint8_t>> packets =
@@ skipping 27 matching lines @@
         1, 4, 8, 0, base::Bind(&ExpectPacketsAndThen, TRANSFER_STATUS_COMPLETED,
                                packets, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 }  // namespace usb
 }  // namespace device