Move device opening from DeviceManager to Device.

device/devices_app/usb/device_manager_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 <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 71 matching lines @@
                           permission_provider.Pass(),
                           base::ThreadTaskRunnerHandle::Get());
     return device_manager.Pass();
   }
 
  private:
   scoped_ptr<TestDeviceClient> device_client_;
   scoped_ptr<base::MessageLoop> message_loop_;
 };
 
-class MockOpenCallback {
- public:
-  explicit MockOpenCallback(UsbDevice* device) : device_(device) {}
-
-  void Open(const UsbDevice::OpenCallback& callback) {
-    device_handle_ = new MockUsbDeviceHandle(device_);
-    callback.Run(device_handle_);
-  }
-
-  scoped_refptr<MockUsbDeviceHandle> mock_handle() { return device_handle_; }
-
- private:
-  UsbDevice* device_;
-  scoped_refptr<MockUsbDeviceHandle> device_handle_;
-};
-
 void ExpectDevicesAndThen(const std::set<std::string>& expected_guids,
                           const base::Closure& continuation,
                           mojo::Array<DeviceInfoPtr> results) {
   EXPECT_EQ(expected_guids.size(), results.size());
   std::set<std::string> actual_guids;
   for (size_t i = 0; i < results.size(); ++i)
     actual_guids.insert(results[i]->guid);
   EXPECT_EQ(expected_guids, actual_guids);
   continuation.Run();
 }
@@ skipping 12 matching lines @@
   std::set<std::string> actual_removed_guids;
   for (size_t i = 0; i < results->devices_removed.size(); ++i)
     actual_removed_guids.insert(results->devices_removed[i]->guid);
   EXPECT_EQ(expected_removed_guids, actual_removed_guids);
   continuation.Run();
 }
 
 void ExpectDeviceInfoAndThen(const std::string& expected_guid,
                              const base::Closure& continuation,
                              DeviceInfoPtr device_info) {
+  ASSERT_TRUE(device_info);
   EXPECT_EQ(expected_guid, device_info->guid);
   continuation.Run();
 }
 
-void ExpectOpenDeviceError(OpenDeviceError expected_error,
-                           OpenDeviceError actual_error) {
-  EXPECT_EQ(expected_error, actual_error);
-}
-
-void FailOnGetDeviceInfoResponse(DeviceInfoPtr device_info) {
-  FAIL();
-}
-
 }  // namespace
 
 // Test basic GetDevices functionality to ensure that all mock devices are
 // returned by the service.
 TEST_F(USBDeviceManagerImplTest, GetDevices) {
   scoped_refptr<MockUsbDevice> device0 =
       new MockUsbDevice(0x1234, 0x5678, "ACME", "Frobinator", "ABCDEF");
   scoped_refptr<MockUsbDevice> device1 =
       new MockUsbDevice(0x1234, 0x5679, "ACME", "Frobinator+", "GHIJKL");
   scoped_refptr<MockUsbDevice> device2 =
@@ skipping 17 matching lines @@
   guids.insert(device2->guid());
 
   base::RunLoop loop;
   device_manager->GetDevices(
       options.Pass(),
       base::Bind(&ExpectDevicesAndThen, guids, loop.QuitClosure()));
   loop.Run();
 }
 
 // Test requesting a single Device by GUID.
-TEST_F(USBDeviceManagerImplTest, OpenDevice) {
+TEST_F(USBDeviceManagerImplTest, GetDevice) {
   scoped_refptr<MockUsbDevice> mock_device =
       new MockUsbDevice(0x1234, 0x5678, "ACME", "Frobinator", "ABCDEF");
 
   mock_usb_service().AddDevice(mock_device);
 
   DeviceManagerPtr device_manager = ConnectToDeviceManager();
 
-  // Should be called on the mock as a result of OpenDevice() below.
-  EXPECT_CALL(*mock_device.get(), Open(_));
-
-  MockOpenCallback open_callback(mock_device.get());
-  ON_CALL(*mock_device.get(), Open(_))
-      .WillByDefault(Invoke(&open_callback, &MockOpenCallback::Open));
-
   {
     base::RunLoop loop;
     DevicePtr device;
-    device_manager->OpenDevice(
-        mock_device->guid(), mojo::GetProxy(&device),
-        base::Bind(&ExpectOpenDeviceError, OPEN_DEVICE_ERROR_OK));
+    device_manager->GetDevice(mock_device->guid(), mojo::GetProxy(&device));
     device->GetDeviceInfo(base::Bind(&ExpectDeviceInfoAndThen,
                                      mock_device->guid(), loop.QuitClosure()));
     loop.Run();
   }
 
-  // The device should eventually be closed when its MessagePipe is closed.
-  DCHECK(open_callback.mock_handle());
-  EXPECT_CALL(*open_callback.mock_handle().get(), Close());
-
   DevicePtr bad_device;
-  device_manager->OpenDevice(
-      "not a real guid", mojo::GetProxy(&bad_device),
-      base::Bind(&ExpectOpenDeviceError, OPEN_DEVICE_ERROR_NOT_FOUND));
+  device_manager->GetDevice("not a real guid", mojo::GetProxy(&bad_device));
 
   {
     base::RunLoop loop;
     bad_device.set_connection_error_handler(loop.QuitClosure());
-    bad_device->GetDeviceInfo(base::Bind(&FailOnGetDeviceInfoResponse));
     loop.Run();
   }
 }
 
 // Test requesting device enumeration updates with GetDeviceChanges.
 TEST_F(USBDeviceManagerImplTest, GetDeviceChanges) {
   scoped_refptr<MockUsbDevice> device0 =
       new MockUsbDevice(0x1234, 0x5678, "ACME", "Frobinator", "ABCDEF");
   scoped_refptr<MockUsbDevice> device1 =
       new MockUsbDevice(0x1234, 0x5679, "ACME", "Frobinator+", "GHIJKL");
@@ skipping 46 matching lines @@
     base::RunLoop loop;
     device_manager->GetDeviceChanges(base::Bind(&ExpectDeviceChangesAndThen,
                                                 added_guids, removed_guids,
                                                 loop.QuitClosure()));
     loop.Run();
   }
 }
 
 }  // namespace usb
 }  // namespace device