Revert of Introduce the devices Mojo app

device/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"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
-#include "base/thread_task_runner_handle.h"
 #include "device/core/device_client.h"
 #include "device/usb/device_impl.h"
 #include "device/usb/device_manager_impl.h"
 #include "device/usb/mock_usb_device.h"
 #include "device/usb/mock_usb_device_handle.h"
 #include "device/usb/mock_usb_service.h"
 #include "device/usb/public/cpp/device_manager_delegate.h"
+#include "device/usb/public/cpp/device_manager_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/mojo/src/mojo/public/cpp/bindings/error_handler.h"
 #include "third_party/mojo/src/mojo/public/cpp/bindings/interface_request.h"
 
 using ::testing::Invoke;
 using ::testing::_;
 
 namespace device {
 namespace usb {
 
 namespace {
 
+bool DefaultDelegateFilter(const DeviceInfo& device_info) {
+  return true;
+}
+
 class TestDeviceManagerDelegate : public DeviceManagerDelegate {
  public:
-  TestDeviceManagerDelegate() {}
+  using Filter = base::Callback<bool(const DeviceInfo&)>;
+
+  TestDeviceManagerDelegate(const Filter& filter) : filter_(filter) {}
   ~TestDeviceManagerDelegate() override {}
 
+  void set_filter(const Filter& filter) { filter_ = filter; }
+
  private:
   // DeviceManagerDelegate implementation:
-  bool IsDeviceAllowed(const DeviceInfo& device_info) override { return true; }
+  bool IsDeviceAllowed(const DeviceInfo& device_info) override {
+    return filter_.Run(device_info);
+  }
+
+  Filter filter_;
 };
 
 class TestDeviceClient : public DeviceClient {
  public:
-  TestDeviceClient() {}
+  TestDeviceClient() : delegate_filter_(base::Bind(&DefaultDelegateFilter)) {}
   ~TestDeviceClient() override {}
 
   MockUsbService& mock_usb_service() { return mock_usb_service_; }
 
+  void SetDelegateFilter(const TestDeviceManagerDelegate::Filter& filter) {
+    delegate_filter_ = filter;
+  }
+
  private:
   // DeviceClient implementation:
   UsbService* GetUsbService() override { return &mock_usb_service_; }
 
+  void ConnectToUSBDeviceManager(
+      mojo::InterfaceRequest<DeviceManager> request) override {
+    new DeviceManagerImpl(request.Pass(),
+                          scoped_ptr<DeviceManagerDelegate>(
+                              new TestDeviceManagerDelegate(delegate_filter_)));
+  }
+
+  TestDeviceManagerDelegate::Filter delegate_filter_;
   MockUsbService mock_usb_service_;
 };
 
 class USBDeviceManagerImplTest : public testing::Test {
  public:
   USBDeviceManagerImplTest()
       : message_loop_(new base::MessageLoop),
         device_client_(new TestDeviceClient) {}
   ~USBDeviceManagerImplTest() override {}
 
  protected:
   MockUsbService& mock_usb_service() {
     return device_client_->mock_usb_service();
   }
 
-  DeviceManagerPtr ConnectToDeviceManager() {
-    DeviceManagerPtr device_manager;
-    new DeviceManagerImpl(
-        mojo::GetProxy(&device_manager),
-        scoped_ptr<DeviceManagerDelegate>(new TestDeviceManagerDelegate),
-        base::ThreadTaskRunnerHandle::Get());
-    return device_manager.Pass();
+  void SetDelegateFilter(const TestDeviceManagerDelegate::Filter& filter) {
+    device_client_->SetDelegateFilter(filter);
   }
 
  private:
   scoped_ptr<base::MessageLoop> message_loop_;
   scoped_ptr<TestDeviceClient> device_client_;
 };
 
 // This is used this to watch a MessagePipe and run a given callback when the
 // pipe is closed.
 class PipeWatcher : public mojo::ErrorHandler {
@@ skipping 63 matching lines @@
       new MockUsbDevice(0x1234, 0x5678, "ACME", "Frobinator", "ABCDEF");
   scoped_refptr<MockUsbDevice> device1 =
       new MockUsbDevice(0x1234, 0x5679, "ACME", "Frobinator+", "GHIJKL");
   scoped_refptr<MockUsbDevice> device2 =
       new MockUsbDevice(0x1234, 0x567a, "ACME", "Frobinator Mk II", "MNOPQR");
 
   mock_usb_service().AddDevice(device0);
   mock_usb_service().AddDevice(device1);
   mock_usb_service().AddDevice(device2);
 
-  DeviceManagerPtr device_manager = ConnectToDeviceManager();
+  DeviceManagerPtr device_manager;
+  DeviceClient::Get()->ConnectToUSBDeviceManager(
+      mojo::GetProxy(&device_manager));
 
   EnumerationOptionsPtr options = EnumerationOptions::New();
   options->filters = mojo::Array<DeviceFilterPtr>::New(1);
   options->filters[0] = DeviceFilter::New();
   options->filters[0]->has_vendor_id = true;
   options->filters[0]->vendor_id = 0x1234;
 
   std::set<std::string> guids;
   guids.insert(device0->guid());
   guids.insert(device1->guid());
@@ skipping 11 matching lines @@
   loop.Run();
 }
 
 // Test requesting a single Device by GUID.
 TEST_F(USBDeviceManagerImplTest, OpenDevice) {
   scoped_refptr<MockUsbDevice> mock_device =
       new MockUsbDevice(0x1234, 0x5678, "ACME", "Frobinator", "ABCDEF");
 
   mock_usb_service().AddDevice(mock_device);
 
-  DeviceManagerPtr device_manager = ConnectToDeviceManager();
+  DeviceManagerPtr device_manager;
+  DeviceClient::Get()->ConnectToUSBDeviceManager(
+      mojo::GetProxy(&device_manager));
 
   // 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));
 
   // Should be called on the mock as a result of GetDeviceInfo() below.
   EXPECT_CALL(*mock_device.get(), GetConfiguration());
@@ skipping 22 matching lines @@
     base::RunLoop loop;
     scoped_ptr<PipeWatcher> watcher(new PipeWatcher(loop.QuitClosure()));
     bad_device.set_error_handler(watcher.get());
     bad_device->GetDeviceInfo(base::Bind(&FailOnGetDeviceInfoResponse));
     loop.Run();
   }
 }
 
 }  // namespace usb
 }  // namespace device