Convert DeviceManagerDelegate to PermissionProvider mojo interface.

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"
 #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/devices_app/usb/device_impl.h"
 #include "device/devices_app/usb/device_manager_impl.h"
-#include "device/devices_app/usb/public/cpp/device_manager_delegate.h"
 #include "device/usb/mock_usb_device.h"
 #include "device/usb/mock_usb_device_handle.h"
 #include "device/usb/mock_usb_service.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 {
 
 namespace {
 
-class TestDeviceManagerDelegate : public DeviceManagerDelegate {
+class TestPermissionProvider : public PermissionProvider {
  public:
-  TestDeviceManagerDelegate() {}
-  ~TestDeviceManagerDelegate() override {}
+  TestPermissionProvider(mojo::InterfaceRequest<PermissionProvider> request)
+      : binding_(this, request.Pass()) {}
+  ~TestPermissionProvider() override {}
+
+  void HasDevicePermission(
+      mojo::Array<mojo::String> requested_guids,
+      const HasDevicePermissionCallback& callback) override {
+    // Permission to access all devices granted.
+    callback.Run(requested_guids.Pass());
+  }
 
  private:
-  // DeviceManagerDelegate implementation:
-  bool IsDeviceAllowed(const DeviceInfo& device_info) override { return true; }
+  mojo::StrongBinding<PermissionProvider> binding_;
 };
 
 class TestDeviceClient : public DeviceClient {
  public:
   TestDeviceClient() {}
   ~TestDeviceClient() override {}
 
   MockUsbService& mock_usb_service() { return mock_usb_service_; }
 
  private:
   // DeviceClient implementation:
   UsbService* GetUsbService() override { return &mock_usb_service_; }
 
   MockUsbService mock_usb_service_;
 };
 
 class USBDeviceManagerImplTest : public testing::Test {
  public:
   USBDeviceManagerImplTest()
       : device_client_(new TestDeviceClient),
         message_loop_(new base::MessageLoop) {}
   ~USBDeviceManagerImplTest() override {}
 
  protected:
   MockUsbService& mock_usb_service() {
     return device_client_->mock_usb_service();
   }
 
   DeviceManagerPtr ConnectToDeviceManager() {
+    PermissionProviderPtr permission_provider;
+    new TestPermissionProvider(mojo::GetProxy(&permission_provider));
     DeviceManagerPtr device_manager;
-    new DeviceManagerImpl(
-        mojo::GetProxy(&device_manager),
-        scoped_ptr<DeviceManagerDelegate>(new TestDeviceManagerDelegate),
-        base::ThreadTaskRunnerHandle::Get());
+    new DeviceManagerImpl(mojo::GetProxy(&device_manager),
+                          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:
@@ skipping 190 matching lines @@
     base::RunLoop loop;
     device_manager->GetDeviceChanges(base::Bind(&ExpectDeviceChangesAndThen,
                                                 added_guids, removed_guids,
                                                 loop.QuitClosure()));
     loop.Run();
   }
 }
 
 }  // namespace usb
 }  // namespace device