Move device opening from DeviceManager to Device.

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"
@@ skipping 33 matching lines @@
     config_.interfaces.push_back(interface);
     return *this;
   }
 
   const UsbConfigDescriptor& config() const { return config_; }
 
  private:
   UsbConfigDescriptor config_;
 };
 
+void ExpectOpenAndThen(OpenDeviceError expected,
+                       const base::Closure& continuation,
+                       OpenDeviceError error) {
+  EXPECT_EQ(expected, error);
+  continuation.Run();
+}
+
 void ExpectDeviceInfoAndThen(const std::string& guid,
                              uint16_t vendor_id,
                              uint16_t product_id,
                              const std::string& manufacturer_name,
                              const std::string& product_name,
                              const std::string& serial_number,
                              const base::Closure& continuation,
                              DeviceInfoPtr device_info) {
   EXPECT_EQ(guid, device_info->guid);
   EXPECT_EQ(vendor_id, device_info->vendor_id);
@@ skipping 68 matching lines @@
 
   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,
                                const std::string& manufacturer,
                                const std::string& product,
                                const std::string& serial) {
-    is_device_open_ = true;
-
     mock_device_ =
         new MockUsbDevice(vendor_id, product_id, manufacturer, product, serial);
     mock_handle_ = new MockUsbDeviceHandle(mock_device_.get());
 
     DevicePtr proxy;
-    new DeviceImpl(mock_handle_, mojo::GetProxy(&proxy));
+    new DeviceImpl(mock_device_, 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_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 22 matching lines @@
 
   void AddMockInboundData(const std::vector<uint8_t>& data) {
     mock_inbound_data_.push(data);
   }
 
   void AddMockOutboundData(const std::vector<uint8_t>& data) {
     mock_outbound_data_.push(data);
   }
 
  private:
+  void OpenMockHandle(const UsbDevice::OpenCallback& callback) {
+    EXPECT_FALSE(is_device_open_);
+    is_device_open_ = true;
+    callback.Run(mock_handle_);
+  }
+
   void CloseMockHandle() {
     EXPECT_TRUE(is_device_open_);
     is_device_open_ = false;
   }
 
   void SetConfiguration(uint8_t value,
                         const UsbDeviceHandle::ResultCallback& callback) {
     if (mock_configs_.find(value) != mock_configs_.end()) {
       current_config_ = value;
       callback.Run(true);
@@ skipping 122 matching lines @@
   std::queue<std::vector<uint8_t>> mock_inbound_data_;
   std::queue<std::vector<uint8_t>> mock_outbound_data_;
 
   std::set<uint8_t> claimed_interfaces_;
 
   DISALLOW_COPY_AND_ASSIGN(USBDeviceImplTest);
 };
 
 }  // namespace
 
+TEST_F(USBDeviceImplTest, Open) {
+  DevicePtr device = GetMockDeviceProxy();
+
+  EXPECT_FALSE(is_device_open());
+
+  EXPECT_CALL(mock_device(), Open(_));
+
+  base::RunLoop loop;
+  device->Open(
+      base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK, loop.QuitClosure()));
+  loop.Run();
+
+  EXPECT_CALL(mock_handle(), Close());
+}
+
 TEST_F(USBDeviceImplTest, Close) {
   DevicePtr device = GetMockDeviceProxy();
 
-  EXPECT_TRUE(is_device_open());
+  EXPECT_FALSE(is_device_open());
+
+  EXPECT_CALL(mock_device(), Open(_));
+
+  {
+    base::RunLoop loop;
+    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+                            loop.QuitClosure()));
+    loop.Run();
+  }
 
   EXPECT_CALL(mock_handle(), Close());
 
-  base::RunLoop loop;
-  device->Close(loop.QuitClosure());
-  loop.Run();
+  {
+    base::RunLoop loop;
+    device->Close(loop.QuitClosure());
+    loop.Run();
+  }
 
   EXPECT_FALSE(is_device_open());
 }
 
 // Test that the information returned via the Device::GetDeviceInfo matches that
 // of the underlying device.
 TEST_F(USBDeviceImplTest, GetDeviceInfo) {
   DevicePtr device =
       GetMockDeviceProxy(0x1234, 0x5678, "ACME", "Frobinator", "ABCDEF");
 
   base::RunLoop loop;
   device->GetDeviceInfo(base::Bind(&ExpectDeviceInfoAndThen,
                                    mock_device().guid(), 0x1234, 0x5678, "ACME",
                                    "Frobinator", "ABCDEF", loop.QuitClosure()));
   loop.Run();
-
-  EXPECT_CALL(mock_handle(), Close());
 }
 
 TEST_F(USBDeviceImplTest, SetInvalidConfiguration) {
   DevicePtr device = GetMockDeviceProxy();
 
+  EXPECT_CALL(mock_device(), Open(_));
+
+  {
+    base::RunLoop loop;
+    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+                            loop.QuitClosure()));
+    loop.Run();
+  }
+
   EXPECT_CALL(mock_handle(), SetConfiguration(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();
+  {
+    // 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, OPEN_DEVICE_ERROR_OK,
+                            loop.QuitClosure()));
+    loop.Run();
+  }
+
   EXPECT_CALL(mock_handle(), SetConfiguration(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();
+  {
+    // SetConfiguration should succeed because 42 is a valid mock configuration.
+    base::RunLoop loop;
+    device->SetConfiguration(
+        42, base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
+    loop.Run();
+  }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 // Verify that the result of Reset() reflects the underlying UsbDeviceHandle's
 // ResetDevice() result.
 TEST_F(USBDeviceImplTest, Reset) {
   DevicePtr device = GetMockDeviceProxy();
 
+  EXPECT_CALL(mock_device(), Open(_));
+
+  {
+    base::RunLoop loop;
+    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+                            loop.QuitClosure()));
+    loop.Run();
+  }
+
   EXPECT_CALL(mock_handle(), ResetDevice(_));
 
   set_allow_reset(true);
 
   {
     base::RunLoop loop;
     device->Reset(base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), ResetDevice(_));
 
   set_allow_reset(false);
 
   {
     base::RunLoop loop;
     device->Reset(base::Bind(&ExpectResultAndThen, false, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 TEST_F(USBDeviceImplTest, ClaimAndReleaseInterface) {
   DevicePtr device = GetMockDeviceProxy();
 
+  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));
 
   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()));
@@ skipping 28 matching lines @@
         1, base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 TEST_F(USBDeviceImplTest, SetInterfaceAlternateSetting) {
   DevicePtr device = GetMockDeviceProxy();
 
+  EXPECT_CALL(mock_device(), Open(_));
+
+  {
+    base::RunLoop loop;
+    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+                            loop.QuitClosure()));
+    loop.Run();
+  }
+
   AddMockConfig(ConfigBuilder(0)
                     .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()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), SetInterfaceAlternateSetting(1, 100, _));
 
   {
     base::RunLoop loop;
     device->SetInterfaceAlternateSetting(
         1, 100, base::Bind(&ExpectResultAndThen, false, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 TEST_F(USBDeviceImplTest, ControlTransfer) {
   DevicePtr device = GetMockDeviceProxy();
 
+  EXPECT_CALL(mock_device(), Open(_));
+
+  {
+    base::RunLoop loop;
+    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+                            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, _));
@@ skipping 34 matching lines @@
                    loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 TEST_F(USBDeviceImplTest, GenericTransfer) {
   DevicePtr device = GetMockDeviceProxy();
 
+  EXPECT_CALL(mock_device(), Open(_));
+
+  {
+    base::RunLoop loop;
+    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+                            loop.QuitClosure()));
+    loop.Run();
+  }
+
   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));
   AddMockOutboundData(fake_outbound_data);
@@ skipping 22 matching lines @@
                    fake_inbound_data, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 TEST_F(USBDeviceImplTest, IsochronousTransfer) {
   DevicePtr device = GetMockDeviceProxy();
 
+  EXPECT_CALL(mock_device(), Open(_));
+
+  {
+    base::RunLoop loop;
+    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+                            loop.QuitClosure()));
+    loop.Run();
+  }
+
   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());
 
@@ skipping 38 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