diff options
Diffstat (limited to 'device/devices_app')
28 files changed, 0 insertions, 3456 deletions
diff --git a/device/devices_app/BUILD.gn b/device/devices_app/BUILD.gn deleted file mode 100644 index f189e6b..0000000 --- a/device/devices_app/BUILD.gn +++ /dev/null @@ -1,77 +0,0 @@ -# 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. - -import("//mojo/public/mojo_application.gni") - -source_set("lib") { - sources = [ - "devices_app.cc", - "devices_app.h", - "usb/device_impl.cc", - "usb/device_impl.h", - "usb/device_manager_impl.cc", - "usb/device_manager_impl.h", - "usb/type_converters.cc", - "usb/type_converters.h", - ] - - deps = [ - "//device/core", - "//device/devices_app/usb/public/interfaces", - "//device/usb", - "//mojo/common", - "//mojo/public/cpp/bindings", - "//mojo/public/cpp/bindings:callback", - "//net", - "//url", - ] - - public_deps = [ - "//base", - "//mojo/shell/public/cpp", - "//mojo/shell/public/interfaces", - ] -} - -if (!is_component_build) { - mojo_native_application("devices") { - sources = [ - "main.cc", - ] - - deps = [ - "//base", - "//device/devices_app/public/cpp:factory", - "//mojo/shell/public/cpp", - ] - - public_deps = [ - ":lib", - ] - } - - mojo_native_application("apptests") { - output_name = "devices_apptests" - - testonly = true - - sources = [ - "devices_apptest.cc", - ] - - deps = [ - "//base", - "//mojo/shell/public/cpp:test_support", - ] - - public_deps = [ - ":lib", - "//device/devices_app/usb/public/interfaces", - ] - - data_deps = [ - ":devices", - ] - } -} diff --git a/device/devices_app/DEPS b/device/devices_app/DEPS deleted file mode 100644 index 7256f77..0000000 --- a/device/devices_app/DEPS +++ /dev/null @@ -1,4 +0,0 @@ -include_rules = [ - "+mojo/shell/public", - "+mojo/common", -] diff --git a/device/devices_app/OWNERS b/device/devices_app/OWNERS deleted file mode 100644 index b16946a..0000000 --- a/device/devices_app/OWNERS +++ /dev/null @@ -1,2 +0,0 @@ -reillyg@chromium.org -rockot@chromium.org diff --git a/device/devices_app/devices_app.cc b/device/devices_app/devices_app.cc deleted file mode 100644 index 8bb9ab9..0000000 --- a/device/devices_app/devices_app.cc +++ /dev/null @@ -1,139 +0,0 @@ -// 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 "device/devices_app/devices_app.h" - -#include <stdint.h> -#include <utility> - -#include "base/bind.h" -#include "base/callback.h" -#include "base/macros.h" -#include "base/sequenced_task_runner.h" -#include "base/thread_task_runner_handle.h" -#include "base/threading/thread.h" -#include "base/time/time.h" -#include "device/core/device_client.h" -#include "device/devices_app/usb/device_manager_impl.h" -#include "device/usb/usb_service.h" -#include "mojo/public/cpp/bindings/interface_request.h" -#include "mojo/shell/public/cpp/connection.h" -#include "mojo/shell/public/cpp/shell.h" -#include "url/gurl.h" - -namespace device { - -namespace { - -// The number of seconds to wait without any bound DeviceManagers before -// exiting the app. -const int64_t kIdleTimeoutInSeconds = 10; - -// A DeviceClient implementation to be constructed iff the app is not running -// in an embedder that provides a DeviceClient (i.e. running as a standalone -// Mojo app, not in Chrome). -class AppDeviceClient : public DeviceClient { - public: - explicit AppDeviceClient( - scoped_refptr<base::SequencedTaskRunner> blocking_task_runner) - : blocking_task_runner_(blocking_task_runner) {} - ~AppDeviceClient() override {} - - private: - // DeviceClient: - UsbService* GetUsbService() override { - if (!usb_service_) { - usb_service_ = UsbService::Create(blocking_task_runner_); - } - return usb_service_.get(); - } - - scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_; - scoped_ptr<UsbService> usb_service_; -}; - -} // namespace - -// This class insures that a UsbService has been initialized and is accessible -// via the DeviceClient interface. -class DevicesApp::USBServiceInitializer { - public: - USBServiceInitializer() - : blocking_thread_("USB service blocking I/O thread") { - blocking_thread_.Start(); - app_device_client_.reset( - new AppDeviceClient(blocking_thread_.task_runner())); - } - - ~USBServiceInitializer() {} - - private: - scoped_ptr<AppDeviceClient> app_device_client_; - base::Thread blocking_thread_; - - DISALLOW_COPY_AND_ASSIGN(USBServiceInitializer); -}; - -DevicesApp::DevicesApp() : shell_(nullptr), active_device_manager_count_(0) {} - -DevicesApp::~DevicesApp() { -} - -void DevicesApp::Initialize(mojo::Shell* shell, - const std::string& url, - uint32_t id) { - shell_ = shell; - service_initializer_.reset(new USBServiceInitializer); - StartIdleTimer(); -} - -bool DevicesApp::AcceptConnection(mojo::Connection* connection) { - connection->AddInterface<usb::DeviceManager>(this); - return true; -} - -void DevicesApp::Quit() { - service_initializer_.reset(); - shell_ = nullptr; -} - -void DevicesApp::Create(mojo::Connection* connection, - mojo::InterfaceRequest<usb::DeviceManager> request) { - // Bind the new device manager to the connecting application's permission - // provider. - usb::PermissionProviderPtr permission_provider; - connection->GetInterface(&permission_provider); - - // Owned by its message pipe. - usb::DeviceManagerImpl* device_manager = new usb::DeviceManagerImpl( - std::move(permission_provider), std::move(request)); - device_manager->set_connection_error_handler( - base::Bind(&DevicesApp::OnConnectionError, base::Unretained(this))); - - active_device_manager_count_++; - idle_timeout_callback_.Cancel(); -} - -void DevicesApp::OnConnectionError() { - DCHECK_GE(active_device_manager_count_, 0u); - active_device_manager_count_--; - if (active_device_manager_count_ == 0) { - // If the last DeviceManager connection has been dropped, kick off an idle - // timeout to shut ourselves down. - StartIdleTimer(); - } -} - -void DevicesApp::StartIdleTimer() { - // Passing unretained |shell_| is safe here because |shell_| is - // guaranteed to outlive |this|, and the callback is canceled if |this| is - // destroyed. - idle_timeout_callback_.Reset( - base::Bind(&mojo::Shell::Quit, base::Unretained(shell_))); - base::ThreadTaskRunnerHandle::Get()->PostDelayedTask( - FROM_HERE, idle_timeout_callback_.callback(), - base::TimeDelta::FromSeconds(kIdleTimeoutInSeconds)); -} - -} // namespace device diff --git a/device/devices_app/devices_app.gyp b/device/devices_app/devices_app.gyp deleted file mode 100644 index 6027a85..0000000 --- a/device/devices_app/devices_app.gyp +++ /dev/null @@ -1,85 +0,0 @@ -# Copyright 2014 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. - -{ - 'variables': { - 'chromium_code': 1, - }, - 'targets': [ - { - 'target_name': 'devices_app_lib', - 'type': 'static_library', - 'include_dirs': [ - '../..', - ], - 'sources': [ - 'devices_app.cc', - 'devices_app.h', - 'usb/device_impl.cc', - 'usb/device_impl.h', - 'usb/device_manager_impl.cc', - 'usb/device_manager_impl.h', - 'usb/type_converters.cc', - 'usb/type_converters.h', - ], - 'dependencies': [ - 'device_usb_mojo_bindings_lib', - '<(DEPTH)/device/core/core.gyp:device_core', - '<(DEPTH)/device/usb/usb.gyp:device_usb', - '<(DEPTH)/mojo/mojo_base.gyp:mojo_application_base', - '<(DEPTH)/mojo/mojo_base.gyp:mojo_application_bindings', - '<(DEPTH)/mojo/mojo_base.gyp:mojo_url_type_converters', - '<(DEPTH)/mojo/mojo_public.gyp:mojo_cpp_bindings', - ], - 'export_dependent_settings': [ - '<(DEPTH)/mojo/mojo_base.gyp:mojo_application_base', - '<(DEPTH)/mojo/mojo_base.gyp:mojo_application_bindings', - '<(DEPTH)/mojo/mojo_public.gyp:mojo_cpp_bindings', - ], - }, - { - 'target_name': 'device_usb_mojo_bindings', - 'type': 'none', - 'variables': { - 'mojom_files': [ - 'usb/public/interfaces/device.mojom', - 'usb/public/interfaces/device_manager.mojom', - 'usb/public/interfaces/permission_provider.mojom', - ], - }, - 'includes': [ - '../../mojo/mojom_bindings_generator_explicit.gypi', - ], - }, - { - 'target_name': 'device_usb_mojo_bindings_lib', - 'type': 'static_library', - 'dependencies': [ - 'device_usb_mojo_bindings', - ], - }, - { - 'target_name': 'devices_app_public_cpp', - 'type': 'static_library', - 'sources': [ - 'public/cpp/constants.cc', - 'public/cpp/constants.h', - ], - 'dependencies': [ - 'devices_app_lib', - ], - }, - { - 'target_name': 'devices_app_public_cpp_factory', - 'type': 'static_library', - 'sources': [ - 'public/cpp/devices_app_factory.cc', - 'public/cpp/devices_app_factory.h', - ], - 'dependencies': [ - 'devices_app_lib', - ], - }, - ], -} diff --git a/device/devices_app/devices_app.h b/device/devices_app/devices_app.h deleted file mode 100644 index 0fecb42..0000000 --- a/device/devices_app/devices_app.h +++ /dev/null @@ -1,67 +0,0 @@ -// 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. - -#ifndef DEVICE_DEVICES_DEVICES_APP_H_ -#define DEVICE_DEVICES_DEVICES_APP_H_ - -#include <stddef.h> - -#include "base/cancelable_callback.h" -#include "base/macros.h" -#include "base/memory/ref_counted.h" -#include "base/memory/scoped_ptr.h" -#include "mojo/shell/public/cpp/interface_factory.h" -#include "mojo/shell/public/cpp/shell_client.h" - -namespace mojo { -class Shell; -} - -namespace device { - -namespace usb { -class DeviceManager; -} - -class DevicesApp : public mojo::ShellClient, - public mojo::InterfaceFactory<usb::DeviceManager> { - public: - DevicesApp(); - ~DevicesApp() override; - - private: - class USBServiceInitializer; - - // mojo::ShellClient: - void Initialize(mojo::Shell* shell, - const std::string& url, - uint32_t id) override; - bool AcceptConnection(mojo::Connection* connection) override; - void Quit() override; - - // mojo::InterfaceFactory<usb::DeviceManager>: - void Create(mojo::Connection* connection, - mojo::InterfaceRequest<usb::DeviceManager> request) override; - - // Mojo error handler to track device manager count. - void OnConnectionError(); - - // Sets the app for destruction after a period of idle time. If any top-level - // services (e.g. usb::DeviceManager) are bound before the timeout elapses, - // it's canceled. - void StartIdleTimer(); - - mojo::Shell* shell_; - scoped_ptr<USBServiceInitializer> service_initializer_; - size_t active_device_manager_count_; - - // Callback used to shut down the app after a period of inactivity. - base::CancelableClosure idle_timeout_callback_; - - DISALLOW_COPY_AND_ASSIGN(DevicesApp); -}; - -} // naespace device - -#endif // DEVICE_DEVICES_DEVICES_APP_H_ diff --git a/device/devices_app/devices_apptest.cc b/device/devices_app/devices_apptest.cc deleted file mode 100644 index 1ac56ae..0000000 --- a/device/devices_app/devices_apptest.cc +++ /dev/null @@ -1,55 +0,0 @@ -// 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 <utility> - -#include "base/bind.h" -#include "base/callback.h" -#include "base/macros.h" -#include "base/run_loop.h" -#include "device/devices_app/devices_app.h" -#include "device/devices_app/usb/public/interfaces/device_manager.mojom.h" -#include "mojo/shell/public/cpp/application_test_base.h" - -namespace device { -namespace { - -class DevicesAppTest : public mojo::test::ApplicationTestBase { - public: - DevicesAppTest() {} - ~DevicesAppTest() override {} - - void SetUp() override { - ApplicationTestBase::SetUp(); - shell()->ConnectToInterface("mojo:devices", &usb_device_manager_); - } - - usb::DeviceManager* usb_device_manager() { return usb_device_manager_.get(); } - - private: - usb::DeviceManagerPtr usb_device_manager_; - - DISALLOW_COPY_AND_ASSIGN(DevicesAppTest); -}; - -void OnGetDevices(const base::Closure& continuation, - mojo::Array<usb::DeviceInfoPtr> devices) { - continuation.Run(); -} - -} // namespace - -// Simple test to verify that we can connect to the USB DeviceManager and get -// a response. -TEST_F(DevicesAppTest, GetUSBDevices) { - base::RunLoop loop; - usb::EnumerationOptionsPtr options = usb::EnumerationOptions::New(); - options->filters = mojo::Array<usb::DeviceFilterPtr>(1); - options->filters[0] = usb::DeviceFilter::New(); - usb_device_manager()->GetDevices( - std::move(options), base::Bind(&OnGetDevices, loop.QuitClosure())); - loop.Run(); -} - -} // namespace device diff --git a/device/devices_app/main.cc b/device/devices_app/main.cc deleted file mode 100644 index 1694aac..0000000 --- a/device/devices_app/main.cc +++ /dev/null @@ -1,15 +0,0 @@ -// 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 "base/sequenced_task_runner.h" -#include "device/devices_app/public/cpp/devices_app_factory.h" -#include "mojo/public/c/system/main.h" -#include "mojo/shell/public/cpp/application_runner.h" -#include "mojo/shell/public/cpp/shell_client.h" - -MojoResult MojoMain(MojoHandle shell_handle) { - mojo::ApplicationRunner runner( - device::DevicesAppFactory::CreateApp().release()); - return runner.Run(shell_handle); -} diff --git a/device/devices_app/public/cpp/BUILD.gn b/device/devices_app/public/cpp/BUILD.gn deleted file mode 100644 index 301d20f..0000000 --- a/device/devices_app/public/cpp/BUILD.gn +++ /dev/null @@ -1,29 +0,0 @@ -# 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. - -source_set("cpp") { - sources = [ - "constants.cc", - "constants.h", - ] - - public_deps = [ - "//base", - ] -} - -source_set("factory") { - sources = [ - "devices_app_factory.cc", - "devices_app_factory.h", - ] - - deps = [ - "//device/devices_app:lib", - ] - - public_deps = [ - "//base", - ] -} diff --git a/device/devices_app/public/cpp/constants.cc b/device/devices_app/public/cpp/constants.cc deleted file mode 100644 index 3bf4e01..0000000 --- a/device/devices_app/public/cpp/constants.cc +++ /dev/null @@ -1,11 +0,0 @@ -// 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 "device/devices_app/public/cpp/constants.h" - -namespace device { - -const char kDevicesMojoAppUrl[] = "mojo:devices"; - -} // namespace device diff --git a/device/devices_app/public/cpp/constants.h b/device/devices_app/public/cpp/constants.h deleted file mode 100644 index dfe242a..0000000 --- a/device/devices_app/public/cpp/constants.h +++ /dev/null @@ -1,14 +0,0 @@ -// 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. - -#ifndef DEVICE_DEVICES_APP_PUBLIC_CPP_CONSTANTS_H_ -#define DEVICE_DEVICES_APP_PUBLIC_CPP_CONSTANTS_H_ - -namespace device { - -extern const char kDevicesMojoAppUrl[]; - -} // namespace device - -#endif // DEVICE_DEVICES_APP_PUBLIC_CPP_CONSTANTS_H_ diff --git a/device/devices_app/public/cpp/devices_app_factory.cc b/device/devices_app/public/cpp/devices_app_factory.cc deleted file mode 100644 index 154f67c..0000000 --- a/device/devices_app/public/cpp/devices_app_factory.cc +++ /dev/null @@ -1,16 +0,0 @@ -// 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 "device/devices_app/public/cpp/devices_app_factory.h" - -#include "device/devices_app/devices_app.h" - -namespace device { - -// static -scoped_ptr<mojo::ShellClient> DevicesAppFactory::CreateApp() { - return scoped_ptr<mojo::ShellClient>(new DevicesApp()); -} - -} // namespace device diff --git a/device/devices_app/public/cpp/devices_app_factory.h b/device/devices_app/public/cpp/devices_app_factory.h deleted file mode 100644 index 6ba7447..0000000 --- a/device/devices_app/public/cpp/devices_app_factory.h +++ /dev/null @@ -1,28 +0,0 @@ -// 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. - -#ifndef DEVICE_DEVICES_APP_PUBLIC_CPP_DEVICES_APP_FACTORY_H_ -#define DEVICE_DEVICES_APP_PUBLIC_CPP_DEVICES_APP_FACTORY_H_ - -#include "base/memory/ref_counted.h" -#include "base/memory/scoped_ptr.h" - -namespace mojo { -class ShellClient; -} - -namespace device { - -// Public factory for creating new instances of the devices app. -class DevicesAppFactory { - public: - // Creates a DevicesApp delegate which can be used to launch a new instance - // of the devices app on a mojo application runner. The caller owns the - // delegate. - static scoped_ptr<mojo::ShellClient> CreateApp(); -}; - -} // namespace device - -#endif // DEVICE_DEVICES_APP_PUBLIC_CPP_DEVICES_APP_FACTORY_H_ diff --git a/device/devices_app/usb/DEPS b/device/devices_app/usb/DEPS deleted file mode 100644 index 134e14a..0000000 --- a/device/devices_app/usb/DEPS +++ /dev/null @@ -1,4 +0,0 @@ -include_rules = [ - "-net", - "+net/base", -] diff --git a/device/devices_app/usb/device_impl.cc b/device/devices_app/usb/device_impl.cc deleted file mode 100644 index 2eb3ed5..0000000 --- a/device/devices_app/usb/device_impl.cc +++ /dev/null @@ -1,464 +0,0 @@ -// 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 "device/devices_app/usb/device_impl.h" - -#include <stddef.h> - -#include <algorithm> -#include <numeric> -#include <utility> -#include <vector> - -#include "base/bind.h" -#include "base/callback.h" -#include "base/stl_util.h" -#include "device/devices_app/usb/type_converters.h" -#include "device/usb/usb_descriptors.h" -#include "device/usb/usb_device.h" -#include "net/base/io_buffer.h" - -namespace device { -namespace usb { - -namespace { - -using MojoTransferInCallback = - mojo::Callback<void(TransferStatus, mojo::Array<uint8_t>)>; - -using MojoTransferOutCallback = mojo::Callback<void(TransferStatus)>; - -template <typename... Args> -void CallMojoCallback(scoped_ptr<mojo::Callback<void(Args...)>> callback, - Args... args) { - callback->Run(args...); -} - -// Generic wrapper to convert a Mojo callback to something we can rebind and -// pass around. This is only usable for callbacks with no move-only arguments. -template <typename... Args> -base::Callback<void(Args...)> WrapMojoCallback( - const mojo::Callback<void(Args...)>& callback) { - // mojo::Callback is not thread safe. By wrapping |callback| in a scoped_ptr - // we guarantee that it will be freed when CallMojoCallback is run and not - // retained until the base::Callback is destroyed, which could happen on any - // thread. This pattern is also used below in places where this generic - // wrapper is not used. - auto callback_ptr = - make_scoped_ptr(new mojo::Callback<void(Args...)>(callback)); - return base::Bind(&CallMojoCallback<Args...>, base::Passed(&callback_ptr)); -} - -void OnPermissionCheckComplete( - const base::Callback<void(bool)>& callback, - const base::Callback<void(const base::Callback<void(bool)>&)>& action, - bool allowed) { - if (allowed) - action.Run(callback); - else - callback.Run(false); -} - -scoped_refptr<net::IOBuffer> CreateTransferBuffer(size_t size) { - scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer( - std::max(static_cast<size_t>(1u), static_cast<size_t>(size))); - return buffer; -} - -void OnTransferIn(scoped_ptr<MojoTransferInCallback> callback, - UsbTransferStatus status, - scoped_refptr<net::IOBuffer> buffer, - size_t buffer_size) { - mojo::Array<uint8_t> data; - if (buffer) { - // TODO(rockot/reillyg): We should change UsbDeviceHandle to use a - // std::vector<uint8_t> instead of net::IOBuffer. Then we could move - // instead of copy. - std::vector<uint8_t> bytes(buffer_size); - std::copy(buffer->data(), buffer->data() + buffer_size, bytes.begin()); - data.Swap(&bytes); - } - callback->Run(mojo::ConvertTo<TransferStatus>(status), std::move(data)); -} - -void OnControlTransferInPermissionCheckComplete( - scoped_refptr<UsbDeviceHandle> device_handle, - ControlTransferParamsPtr params, - int length, - int timeout, - scoped_ptr<Device::ControlTransferInCallback> callback, - bool allowed) { - if (allowed) { - scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(length); - device_handle->ControlTransfer( - USB_DIRECTION_INBOUND, - mojo::ConvertTo<UsbDeviceHandle::TransferRequestType>(params->type), - mojo::ConvertTo<UsbDeviceHandle::TransferRecipient>(params->recipient), - params->request, params->value, params->index, buffer, length, timeout, - base::Bind(&OnTransferIn, base::Passed(&callback))); - } else { - mojo::Array<uint8_t> data; - callback->Run(TransferStatus::PERMISSION_DENIED, std::move(data)); - } -} - -void OnTransferOut(scoped_ptr<MojoTransferOutCallback> callback, - UsbTransferStatus status, - scoped_refptr<net::IOBuffer> buffer, - size_t buffer_size) { - callback->Run(mojo::ConvertTo<TransferStatus>(status)); -} - -void OnControlTransferOutPermissionCheckComplete( - scoped_refptr<UsbDeviceHandle> device_handle, - ControlTransferParamsPtr params, - mojo::Array<uint8_t> data, - int timeout, - scoped_ptr<Device::ControlTransferOutCallback> callback, - bool allowed) { - if (allowed) { - scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(data.size()); - const std::vector<uint8_t>& storage = data.storage(); - std::copy(storage.begin(), storage.end(), buffer->data()); - device_handle->ControlTransfer( - USB_DIRECTION_OUTBOUND, - mojo::ConvertTo<UsbDeviceHandle::TransferRequestType>(params->type), - mojo::ConvertTo<UsbDeviceHandle::TransferRecipient>(params->recipient), - params->request, params->value, params->index, buffer, data.size(), - timeout, base::Bind(&OnTransferOut, base::Passed(&callback))); - } else { - callback->Run(TransferStatus::PERMISSION_DENIED); - } -} - -mojo::Array<IsochronousPacketPtr> BuildIsochronousPacketArray( - mojo::Array<uint32_t> packet_lengths, - TransferStatus status) { - mojo::Array<IsochronousPacketPtr> packets(packet_lengths.size()); - for (size_t i = 0; i < packet_lengths.size(); ++i) { - packets[i] = IsochronousPacket::New(); - packets[i]->length = packet_lengths[i]; - packets[i]->status = status; - } - return packets; -} - -void OnIsochronousTransferIn( - scoped_ptr<Device::IsochronousTransferInCallback> callback, - scoped_refptr<net::IOBuffer> buffer, - const std::vector<UsbDeviceHandle::IsochronousPacket>& packets) { - mojo::Array<uint8_t> data; - if (buffer) { - // TODO(rockot/reillyg): We should change UsbDeviceHandle to use a - // std::vector<uint8_t> instead of net::IOBuffer. Then we could move - // instead of copy. - uint32_t buffer_size = - std::accumulate(packets.begin(), packets.end(), 0u, - [](const uint32_t& a, - const UsbDeviceHandle::IsochronousPacket& packet) { - return a + packet.length; - }); - std::vector<uint8_t> bytes(buffer_size); - std::copy(buffer->data(), buffer->data() + buffer_size, bytes.begin()); - data.Swap(&bytes); - } - callback->Run(std::move(data), - mojo::Array<IsochronousPacketPtr>::From(packets)); -} - -void OnIsochronousTransferOut( - scoped_ptr<Device::IsochronousTransferOutCallback> callback, - scoped_refptr<net::IOBuffer> buffer, - const std::vector<UsbDeviceHandle::IsochronousPacket>& packets) { - callback->Run(mojo::Array<IsochronousPacketPtr>::From(packets)); -} - -} // namespace - -DeviceImpl::DeviceImpl(scoped_refptr<UsbDevice> device, - PermissionProviderPtr permission_provider, - mojo::InterfaceRequest<Device> request) - : binding_(this, std::move(request)), - device_(device), - permission_provider_(std::move(permission_provider)), - weak_factory_(this) { - // This object owns itself and will be destroyed if either the message pipe - // it is bound to is closed or the PermissionProvider it depends on is - // unavailable. - binding_.set_connection_error_handler([this]() { delete this; }); - permission_provider_.set_connection_error_handler([this]() { delete this; }); -} - -DeviceImpl::~DeviceImpl() { - CloseHandle(); -} - -void DeviceImpl::CloseHandle() { - if (device_handle_) - device_handle_->Close(); - device_handle_ = nullptr; -} - -void DeviceImpl::HasControlTransferPermission( - ControlTransferRecipient recipient, - uint16_t index, - const base::Callback<void(bool)>& callback) { - DCHECK(device_handle_); - const UsbConfigDescriptor* config = device_->GetActiveConfiguration(); - - if (recipient == ControlTransferRecipient::INTERFACE || - recipient == ControlTransferRecipient::ENDPOINT) { - if (!config) { - callback.Run(false); - return; - } - - uint8_t interface_number = index & 0xff; - if (recipient == ControlTransferRecipient::ENDPOINT) { - if (!device_handle_->FindInterfaceByEndpoint(index & 0xff, - &interface_number)) { - callback.Run(false); - return; - } - } - - permission_provider_->HasInterfacePermission( - interface_number, config->configuration_value, - DeviceInfo::From(*device_), callback); - } else if (config) { - permission_provider_->HasConfigurationPermission( - config->configuration_value, DeviceInfo::From(*device_), callback); - } else { - // Client must already have device permission to have gotten this far. - callback.Run(true); - } -} - -void DeviceImpl::OnOpen(const OpenCallback& callback, - scoped_refptr<UsbDeviceHandle> handle) { - device_handle_ = handle; - callback.Run(handle ? OpenDeviceError::OK : OpenDeviceError::ACCESS_DENIED); -} - -void DeviceImpl::GetDeviceInfo(const GetDeviceInfoCallback& callback) { - callback.Run(DeviceInfo::From(*device_)); -} - -void DeviceImpl::GetConfiguration(const GetConfigurationCallback& callback) { - const UsbConfigDescriptor* config = device_->GetActiveConfiguration(); - callback.Run(config ? config->configuration_value : 0); -} - -void DeviceImpl::Open(const OpenCallback& callback) { - device_->Open( - base::Bind(&DeviceImpl::OnOpen, weak_factory_.GetWeakPtr(), callback)); -} - -void DeviceImpl::Close(const CloseCallback& callback) { - CloseHandle(); - callback.Run(); -} - -void DeviceImpl::SetConfiguration(uint8_t value, - const SetConfigurationCallback& callback) { - if (!device_handle_) { - callback.Run(false); - return; - } - - auto set_configuration = - base::Bind(&UsbDeviceHandle::SetConfiguration, device_handle_, value); - permission_provider_->HasConfigurationPermission( - value, DeviceInfo::From(*device_), - base::Bind(&OnPermissionCheckComplete, WrapMojoCallback(callback), - set_configuration)); -} - -void DeviceImpl::ClaimInterface(uint8_t interface_number, - const ClaimInterfaceCallback& callback) { - if (!device_handle_) { - callback.Run(false); - return; - } - - const UsbConfigDescriptor* config = device_->GetActiveConfiguration(); - if (!config) { - callback.Run(false); - return; - } - - auto claim_interface = base::Bind(&UsbDeviceHandle::ClaimInterface, - device_handle_, interface_number); - permission_provider_->HasInterfacePermission( - interface_number, config->configuration_value, DeviceInfo::From(*device_), - base::Bind(&OnPermissionCheckComplete, WrapMojoCallback(callback), - claim_interface)); -} - -void DeviceImpl::ReleaseInterface(uint8_t interface_number, - const ReleaseInterfaceCallback& callback) { - if (!device_handle_) { - callback.Run(false); - return; - } - - device_handle_->ReleaseInterface(interface_number, - WrapMojoCallback(callback)); -} - -void DeviceImpl::SetInterfaceAlternateSetting( - uint8_t interface_number, - uint8_t alternate_setting, - const SetInterfaceAlternateSettingCallback& callback) { - if (!device_handle_) { - callback.Run(false); - return; - } - - device_handle_->SetInterfaceAlternateSetting( - interface_number, alternate_setting, WrapMojoCallback(callback)); -} - -void DeviceImpl::Reset(const ResetCallback& callback) { - if (!device_handle_) { - callback.Run(false); - return; - } - - device_handle_->ResetDevice(WrapMojoCallback(callback)); -} - -void DeviceImpl::ClearHalt(uint8_t endpoint, - const ClearHaltCallback& callback) { - if (!device_handle_) { - callback.Run(false); - return; - } - - device_handle_->ClearHalt(endpoint, WrapMojoCallback(callback)); -} - -void DeviceImpl::ControlTransferIn(ControlTransferParamsPtr params, - uint32_t length, - uint32_t timeout, - const ControlTransferInCallback& callback) { - if (!device_handle_) { - callback.Run(TransferStatus::TRANSFER_ERROR, mojo::Array<uint8_t>()); - return; - } - - auto callback_ptr = make_scoped_ptr(new ControlTransferInCallback(callback)); - ControlTransferRecipient recipient = params->recipient; - uint16_t index = params->index; - HasControlTransferPermission( - recipient, index, - base::Bind(&OnControlTransferInPermissionCheckComplete, device_handle_, - base::Passed(¶ms), length, timeout, - base::Passed(&callback_ptr))); -} - -void DeviceImpl::ControlTransferOut( - ControlTransferParamsPtr params, - mojo::Array<uint8_t> data, - uint32_t timeout, - const ControlTransferOutCallback& callback) { - if (!device_handle_) { - callback.Run(TransferStatus::TRANSFER_ERROR); - return; - } - - auto callback_ptr = make_scoped_ptr(new ControlTransferOutCallback(callback)); - ControlTransferRecipient recipient = params->recipient; - uint16_t index = params->index; - HasControlTransferPermission( - recipient, index, - base::Bind(&OnControlTransferOutPermissionCheckComplete, device_handle_, - base::Passed(¶ms), base::Passed(&data), timeout, - base::Passed(&callback_ptr))); -} - -void DeviceImpl::GenericTransferIn(uint8_t endpoint_number, - uint32_t length, - uint32_t timeout, - const GenericTransferInCallback& callback) { - if (!device_handle_) { - callback.Run(TransferStatus::TRANSFER_ERROR, mojo::Array<uint8_t>()); - return; - } - - auto callback_ptr = make_scoped_ptr(new GenericTransferInCallback(callback)); - uint8_t endpoint_address = endpoint_number | 0x80; - scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(length); - device_handle_->GenericTransfer( - USB_DIRECTION_INBOUND, endpoint_address, buffer, length, timeout, - base::Bind(&OnTransferIn, base::Passed(&callback_ptr))); -} - -void DeviceImpl::GenericTransferOut( - uint8_t endpoint_number, - mojo::Array<uint8_t> data, - uint32_t timeout, - const GenericTransferOutCallback& callback) { - if (!device_handle_) { - callback.Run(TransferStatus::TRANSFER_ERROR); - return; - } - - auto callback_ptr = make_scoped_ptr(new GenericTransferOutCallback(callback)); - uint8_t endpoint_address = endpoint_number; - scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(data.size()); - const std::vector<uint8_t>& storage = data.storage(); - std::copy(storage.begin(), storage.end(), buffer->data()); - device_handle_->GenericTransfer( - USB_DIRECTION_OUTBOUND, endpoint_address, buffer, data.size(), timeout, - base::Bind(&OnTransferOut, base::Passed(&callback_ptr))); -} - -void DeviceImpl::IsochronousTransferIn( - uint8_t endpoint_number, - mojo::Array<uint32_t> packet_lengths, - uint32_t timeout, - const IsochronousTransferInCallback& callback) { - if (!device_handle_) { - callback.Run(mojo::Array<uint8_t>(), - BuildIsochronousPacketArray(std::move(packet_lengths), - TransferStatus::TRANSFER_ERROR)); - return; - } - - auto callback_ptr = - make_scoped_ptr(new IsochronousTransferInCallback(callback)); - uint8_t endpoint_address = endpoint_number | 0x80; - device_handle_->IsochronousTransferIn( - endpoint_address, packet_lengths.storage(), timeout, - base::Bind(&OnIsochronousTransferIn, base::Passed(&callback_ptr))); -} - -void DeviceImpl::IsochronousTransferOut( - uint8_t endpoint_number, - mojo::Array<uint8_t> data, - mojo::Array<uint32_t> packet_lengths, - uint32_t timeout, - const IsochronousTransferOutCallback& callback) { - if (!device_handle_) { - callback.Run(BuildIsochronousPacketArray(std::move(packet_lengths), - TransferStatus::TRANSFER_ERROR)); - return; - } - - auto callback_ptr = - make_scoped_ptr(new IsochronousTransferOutCallback(callback)); - uint8_t endpoint_address = endpoint_number; - scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(data.size()); - { - const std::vector<uint8_t>& storage = data.storage(); - std::copy(storage.begin(), storage.end(), buffer->data()); - } - device_handle_->IsochronousTransferOut( - endpoint_address, buffer, packet_lengths.storage(), timeout, - base::Bind(&OnIsochronousTransferOut, base::Passed(&callback_ptr))); -} - -} // namespace usb -} // namespace device diff --git a/device/devices_app/usb/device_impl.h b/device/devices_app/usb/device_impl.h deleted file mode 100644 index 2b438c8..0000000 --- a/device/devices_app/usb/device_impl.h +++ /dev/null @@ -1,113 +0,0 @@ -// 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. - -#ifndef DEVICE_DEVICES_APP_USB_DEVICE_IMPL_H_ -#define DEVICE_DEVICES_APP_USB_DEVICE_IMPL_H_ - -#include <stdint.h> - -#include "base/callback_forward.h" -#include "base/macros.h" -#include "base/memory/ref_counted.h" -#include "base/memory/weak_ptr.h" -#include "device/devices_app/usb/public/interfaces/device.mojom.h" -#include "device/devices_app/usb/public/interfaces/permission_provider.mojom.h" -#include "device/usb/usb_device_handle.h" -#include "mojo/public/cpp/bindings/binding.h" -#include "mojo/public/cpp/bindings/callback.h" -#include "mojo/public/cpp/bindings/interface_request.h" - -namespace net { -class IOBuffer; -} - -namespace device { -namespace usb { - -// Implementation of the public Device interface. Instances of this class are -// constructed by DeviceManagerImpl and are strongly bound to their MessagePipe -// lifetime. -class DeviceImpl : public Device { - public: - DeviceImpl(scoped_refptr<UsbDevice> device, - PermissionProviderPtr permission_provider, - mojo::InterfaceRequest<Device> request); - ~DeviceImpl() override; - - private: - // Closes the device if it's open. This will always set |device_handle_| to - // null. - void CloseHandle(); - - // Checks interface permissions for control transfers. - void HasControlTransferPermission(ControlTransferRecipient recipient, - uint16_t index, - const base::Callback<void(bool)>& callback); - - // Handles completion of an open request. - void OnOpen(const OpenCallback& callback, - scoped_refptr<device::UsbDeviceHandle> handle); - - // Device implementation: - void GetDeviceInfo(const GetDeviceInfoCallback& callback) override; - void GetConfiguration(const GetConfigurationCallback& callback) override; - void Open(const OpenCallback& callback) override; - void Close(const CloseCallback& callback) override; - void SetConfiguration(uint8_t value, - const SetConfigurationCallback& callback) override; - void ClaimInterface(uint8_t interface_number, - const ClaimInterfaceCallback& callback) override; - void ReleaseInterface(uint8_t interface_number, - const ReleaseInterfaceCallback& callback) override; - void SetInterfaceAlternateSetting( - uint8_t interface_number, - uint8_t alternate_setting, - const SetInterfaceAlternateSettingCallback& callback) override; - void Reset(const ResetCallback& callback) override; - void ClearHalt(uint8_t endpoint, const ClearHaltCallback& callback) override; - void ControlTransferIn(ControlTransferParamsPtr params, - uint32_t length, - uint32_t timeout, - const ControlTransferInCallback& callback) override; - void ControlTransferOut(ControlTransferParamsPtr params, - mojo::Array<uint8_t> data, - uint32_t timeout, - const ControlTransferOutCallback& callback) override; - void GenericTransferIn(uint8_t endpoint_number, - uint32_t length, - uint32_t timeout, - const GenericTransferInCallback& callback) override; - void GenericTransferOut(uint8_t endpoint_number, - mojo::Array<uint8_t> data, - uint32_t timeout, - const GenericTransferOutCallback& callback) override; - void IsochronousTransferIn( - uint8_t endpoint_number, - mojo::Array<uint32_t> packet_lengths, - uint32_t timeout, - const IsochronousTransferInCallback& callback) override; - void IsochronousTransferOut( - uint8_t endpoint_number, - mojo::Array<uint8_t> data, - mojo::Array<uint32_t> packet_lengths, - uint32_t timeout, - const IsochronousTransferOutCallback& callback) override; - - mojo::Binding<Device> binding_; - - scoped_refptr<UsbDevice> device_; - // The device handle. Will be null before the device is opened and after it - // has been closed. - scoped_refptr<UsbDeviceHandle> device_handle_; - PermissionProviderPtr permission_provider_; - - base::WeakPtrFactory<DeviceImpl> weak_factory_; - - DISALLOW_COPY_AND_ASSIGN(DeviceImpl); -}; - -} // namespace usb -} // namespace device - -#endif // DEVICE_DEVICES_APP_USB_DEVICE_IMPL_H_ diff --git a/device/devices_app/usb/device_impl_unittest.cc b/device/devices_app/usb/device_impl_unittest.cc deleted file mode 100644 index b98d330..0000000 --- a/device/devices_app/usb/device_impl_unittest.cc +++ /dev/null @@ -1,895 +0,0 @@ -// 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 "device/devices_app/usb/device_impl.h" - -#include <stddef.h> -#include <stdint.h> - -#include <map> -#include <numeric> -#include <queue> -#include <set> -#include <string> -#include <utility> -#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/fake_permission_provider.h" -#include "device/usb/mock_usb_device.h" -#include "device/usb/mock_usb_device_handle.h" -#include "mojo/public/cpp/bindings/interface_request.h" -#include "net/base/io_buffer.h" -#include "testing/gtest/include/gtest/gtest.h" - -using ::testing::Invoke; -using ::testing::_; - -namespace device { -namespace usb { - -namespace { - -class ConfigBuilder { - public: - explicit ConfigBuilder(uint8_t value) { config_.configuration_value = value; } - - ConfigBuilder& AddInterface(uint8_t interface_number, - uint8_t alternate_setting, - uint8_t class_code, - uint8_t subclass_code, - uint8_t protocol_code) { - UsbInterfaceDescriptor interface; - interface.interface_number = interface_number; - interface.alternate_setting = alternate_setting; - interface.interface_class = class_code; - interface.interface_subclass = subclass_code; - interface.interface_protocol = protocol_code; - 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); - EXPECT_EQ(product_id, device_info->product_id); - EXPECT_EQ(manufacturer_name, device_info->manufacturer_name); - EXPECT_EQ(product_name, device_info->product_name); - EXPECT_EQ(serial_number, device_info->serial_number); - continuation.Run(); -} - -void ExpectResultAndThen(bool expected_result, - const base::Closure& continuation, - bool actual_result) { - EXPECT_EQ(expected_result, actual_result); - continuation.Run(); -} - -void ExpectTransferInAndThen(TransferStatus expected_status, - const std::vector<uint8_t>& expected_bytes, - const base::Closure& continuation, - TransferStatus actual_status, - mojo::Array<uint8_t> actual_bytes) { - EXPECT_EQ(expected_status, actual_status); - ASSERT_EQ(expected_bytes.size(), actual_bytes.size()); - for (size_t i = 0; i < actual_bytes.size(); ++i) { - EXPECT_EQ(expected_bytes[i], actual_bytes[i]) - << "Contents differ at index: " << i; - } - continuation.Run(); -} - -void ExpectPacketsOutAndThen(const std::vector<uint32_t>& expected_packets, - const base::Closure& continuation, - mojo::Array<IsochronousPacketPtr> actual_packets) { - ASSERT_EQ(expected_packets.size(), actual_packets.size()); - for (size_t i = 0; i < expected_packets.size(); ++i) { - EXPECT_EQ(expected_packets[i], actual_packets[i]->transferred_length) - << "Packet lengths differ at index: " << i; - EXPECT_EQ(TransferStatus::COMPLETED, actual_packets[i]->status) - << "Packet at index " << i << " not completed."; - } - continuation.Run(); -} - -void ExpectPacketsInAndThen(const std::vector<uint8_t>& expected_bytes, - const std::vector<uint32_t>& expected_packets, - const base::Closure& continuation, - mojo::Array<uint8_t> actual_bytes, - mojo::Array<IsochronousPacketPtr> actual_packets) { - ASSERT_EQ(expected_packets.size(), actual_packets.size()); - for (size_t i = 0; i < expected_packets.size(); ++i) { - EXPECT_EQ(expected_packets[i], actual_packets[i]->transferred_length) - << "Packet lengths differ at index: " << i; - EXPECT_EQ(TransferStatus::COMPLETED, actual_packets[i]->status) - << "Packet at index " << i << " not completed."; - } - ASSERT_EQ(expected_bytes.size(), actual_bytes.size()); - for (size_t i = 0; i < expected_bytes.size(); ++i) { - EXPECT_EQ(expected_bytes[i], actual_bytes[i]) - << "Contents differ at index: " << i; - } - continuation.Run(); -} - -void ExpectTransferStatusAndThen(TransferStatus expected_status, - const base::Closure& continuation, - TransferStatus actual_status) { - EXPECT_EQ(expected_status, actual_status); - continuation.Run(); -} - -class USBDeviceImplTest : public testing::Test { - public: - USBDeviceImplTest() - : message_loop_(new base::MessageLoop), - is_device_open_(false), - allow_reset_(false), - current_config_(0) {} - - ~USBDeviceImplTest() override {} - - protected: - MockUsbDevice& mock_device() { return *mock_device_.get(); } - bool is_device_open() const { return is_device_open_; } - MockUsbDeviceHandle& mock_handle() { return *mock_handle_.get(); } - - 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) { - 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_, std::move(permission_provider), - 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( - Invoke(this, &USBDeviceImplTest::SetInterfaceAlternateSetting)); - ON_CALL(mock_handle(), ResetDevice(_)) - .WillByDefault(Invoke(this, &USBDeviceImplTest::ResetDevice)); - ON_CALL(mock_handle(), ControlTransfer(_, _, _, _, _, _, _, _, _, _)) - .WillByDefault(Invoke(this, &USBDeviceImplTest::ControlTransfer)); - ON_CALL(mock_handle(), GenericTransfer(_, _, _, _, _, _)) - .WillByDefault(Invoke(this, &USBDeviceImplTest::GenericTransfer)); - ON_CALL(mock_handle(), IsochronousTransferIn(_, _, _, _)) - .WillByDefault(Invoke(this, &USBDeviceImplTest::IsochronousTransferIn)); - ON_CALL(mock_handle(), IsochronousTransferOut(_, _, _, _, _)) - .WillByDefault( - Invoke(this, &USBDeviceImplTest::IsochronousTransferOut)); - - return proxy; - } - - DevicePtr GetMockDeviceProxy() { - return GetMockDeviceProxy(0x1234, 0x5678, "ACME", "Frobinator", "ABCDEF"); - } - - void AddMockConfig(const ConfigBuilder& builder) { - const UsbConfigDescriptor& config = builder.config(); - DCHECK(!ContainsKey(mock_configs_, config.configuration_value)); - mock_configs_[config.configuration_value] = config; - } - - void AddMockInboundData(const std::vector<uint8_t>& data) { - mock_inbound_data_.push(data); - } - - void AddMockInboundPackets( - const std::vector<uint8_t>& data, - const std::vector<UsbDeviceHandle::IsochronousPacket>& packets) { - mock_inbound_data_.push(data); - mock_inbound_packets_.push(packets); - } - - void AddMockOutboundData(const std::vector<uint8_t>& data) { - mock_outbound_data_.push(data); - } - - void AddMockOutboundPackets( - const std::vector<uint8_t>& data, - const std::vector<UsbDeviceHandle::IsochronousPacket>& packets) { - mock_outbound_data_.push(data); - mock_outbound_packets_.push(packets); - } - - 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; - } - - 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); - } - } - - void ClaimInterface(uint8_t interface_number, - const UsbDeviceHandle::ResultCallback& callback) { - for (const auto& config : mock_configs_) { - for (const auto& interface : config.second.interfaces) { - if (interface.interface_number == interface_number) { - claimed_interfaces_.insert(interface_number); - callback.Run(true); - return; - } - } - } - callback.Run(false); - } - - void ReleaseInterface(uint8_t interface_number, - const UsbDeviceHandle::ResultCallback& callback) { - if (ContainsKey(claimed_interfaces_, interface_number)) { - claimed_interfaces_.erase(interface_number); - callback.Run(true); - } else { - callback.Run(false); - } - } - - void SetInterfaceAlternateSetting( - uint8_t interface_number, - uint8_t alternate_setting, - const UsbDeviceHandle::ResultCallback& callback) { - for (const auto& config : mock_configs_) { - for (const auto& interface : config.second.interfaces) { - if (interface.interface_number == interface_number && - interface.alternate_setting == alternate_setting) { - callback.Run(true); - return; - } - } - } - callback.Run(false); - } - - void ResetDevice(const UsbDeviceHandle::ResultCallback& callback) { - callback.Run(allow_reset_); - } - - void InboundTransfer(const UsbDeviceHandle::TransferCallback& callback) { - ASSERT_GE(mock_inbound_data_.size(), 1u); - const std::vector<uint8_t>& bytes = mock_inbound_data_.front(); - size_t length = bytes.size(); - scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(length); - std::copy(bytes.begin(), bytes.end(), buffer->data()); - mock_inbound_data_.pop(); - callback.Run(USB_TRANSFER_COMPLETED, buffer, length); - } - - void OutboundTransfer(scoped_refptr<net::IOBuffer> buffer, - size_t length, - const UsbDeviceHandle::TransferCallback& callback) { - ASSERT_GE(mock_outbound_data_.size(), 1u); - const std::vector<uint8_t>& bytes = mock_outbound_data_.front(); - ASSERT_EQ(bytes.size(), length); - for (size_t i = 0; i < length; ++i) { - EXPECT_EQ(bytes[i], buffer->data()[i]) - << "Contents differ at index: " << i; - } - mock_outbound_data_.pop(); - callback.Run(USB_TRANSFER_COMPLETED, buffer, length); - } - - void ControlTransfer(UsbEndpointDirection direction, - UsbDeviceHandle::TransferRequestType request_type, - UsbDeviceHandle::TransferRecipient recipient, - uint8_t request, - uint16_t value, - uint16_t index, - scoped_refptr<net::IOBuffer> buffer, - size_t length, - unsigned int timeout, - const UsbDeviceHandle::TransferCallback& callback) { - if (direction == USB_DIRECTION_INBOUND) - InboundTransfer(callback); - else - OutboundTransfer(buffer, length, callback); - } - - void GenericTransfer(UsbEndpointDirection direction, - uint8_t endpoint, - scoped_refptr<net::IOBuffer> buffer, - size_t length, - unsigned int timeout, - const UsbDeviceHandle::TransferCallback& callback) { - if (direction == USB_DIRECTION_INBOUND) - InboundTransfer(callback); - else - OutboundTransfer(buffer, length, callback); - } - - void IsochronousTransferIn( - uint8_t endpoint_number, - const std::vector<uint32_t>& packet_lengths, - unsigned int timeout, - const UsbDeviceHandle::IsochronousTransferCallback& callback) { - ASSERT_FALSE(mock_inbound_data_.empty()); - const std::vector<uint8_t>& bytes = mock_inbound_data_.front(); - size_t length = bytes.size(); - scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(length); - std::copy(bytes.begin(), bytes.end(), buffer->data()); - mock_inbound_data_.pop(); - - ASSERT_FALSE(mock_inbound_packets_.empty()); - std::vector<UsbDeviceHandle::IsochronousPacket> packets = - mock_inbound_packets_.front(); - ASSERT_EQ(packets.size(), packet_lengths.size()); - for (size_t i = 0; i < packets.size(); ++i) { - EXPECT_EQ(packets[i].length, packet_lengths[i]) - << "Packet lengths differ at index: " << i; - } - mock_inbound_packets_.pop(); - - callback.Run(buffer, packets); - } - - void IsochronousTransferOut( - uint8_t endpoint_number, - scoped_refptr<net::IOBuffer> buffer, - const std::vector<uint32_t>& packet_lengths, - unsigned int timeout, - const UsbDeviceHandle::IsochronousTransferCallback& callback) { - ASSERT_FALSE(mock_outbound_data_.empty()); - const std::vector<uint8_t>& bytes = mock_outbound_data_.front(); - size_t length = - std::accumulate(packet_lengths.begin(), packet_lengths.end(), 0u); - ASSERT_EQ(bytes.size(), length); - for (size_t i = 0; i < length; ++i) { - EXPECT_EQ(bytes[i], buffer->data()[i]) << "Contents differ at index: " - << i; - } - mock_outbound_data_.pop(); - - ASSERT_FALSE(mock_outbound_packets_.empty()); - std::vector<UsbDeviceHandle::IsochronousPacket> packets = - mock_outbound_packets_.front(); - ASSERT_EQ(packets.size(), packet_lengths.size()); - for (size_t i = 0; i < packets.size(); ++i) { - EXPECT_EQ(packets[i].length, packet_lengths[i]) - << "Packet lengths differ at index: " << i; - } - mock_outbound_packets_.pop(); - - callback.Run(buffer, packets); - } - - scoped_ptr<base::MessageLoop> message_loop_; - scoped_refptr<MockUsbDevice> mock_device_; - scoped_refptr<MockUsbDeviceHandle> mock_handle_; - bool is_device_open_; - 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::queue<std::vector<UsbDeviceHandle::IsochronousPacket>> - mock_inbound_packets_; - std::queue<std::vector<UsbDeviceHandle::IsochronousPacket>> - mock_outbound_packets_; - - 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()); - - EXPECT_CALL(mock_device(), Open(_)); - - base::RunLoop loop; - device->Open( - base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK, loop.QuitClosure())); - loop.Run(); - - EXPECT_CALL(mock_handle(), Close()); -} - -TEST_F(USBDeviceImplTest, Close) { - DevicePtr device = GetMockDeviceProxy(); - - EXPECT_FALSE(is_device_open()); - - EXPECT_CALL(mock_device(), Open(_)); - - { - base::RunLoop loop; - device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK, - loop.QuitClosure())); - loop.Run(); - } - - EXPECT_CALL(mock_handle(), Close()); - - { - 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(); -} - -TEST_F(USBDeviceImplTest, SetInvalidConfiguration) { - DevicePtr device = GetMockDeviceProxy(); - - EXPECT_CALL(mock_device(), Open(_)); - - { - base::RunLoop loop; - device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::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(); - } - - 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, OpenDeviceError::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(); - } - - 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, OpenDeviceError::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, OpenDeviceError::OK, - loop.QuitClosure())); - loop.Run(); - } - - // Now add a mock interface #1. - 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, _)); - - { - // Releasing a non-existent interface should fail. - base::RunLoop loop; - device->ReleaseInterface( - 2, base::Bind(&ExpectResultAndThen, false, loop.QuitClosure())); - loop.Run(); - } - - EXPECT_CALL(mock_handle(), ReleaseInterface(1, _)); - - { - // Now this should release the claimed interface and close the handle. - base::RunLoop loop; - device->ReleaseInterface( - 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, OpenDeviceError::OK, - loop.QuitClosure())); - loop.Run(); - } - - 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())); - 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, OpenDeviceError::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 = ControlTransferType::STANDARD; - params->recipient = ControlTransferRecipient::DEVICE; - params->request = 5; - params->value = 6; - params->index = 7; - base::RunLoop loop; - device->ControlTransferIn( - std::move(params), static_cast<uint32_t>(fake_data.size()), 0, - base::Bind(&ExpectTransferInAndThen, TransferStatus::COMPLETED, - fake_data, loop.QuitClosure())); - loop.Run(); - } - - 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 = ControlTransferType::STANDARD; - params->recipient = ControlTransferRecipient::INTERFACE; - params->request = 5; - params->value = 6; - params->index = 7; - base::RunLoop loop; - device->ControlTransferOut( - std::move(params), mojo::Array<uint8_t>::From(fake_data), 0, - base::Bind(&ExpectTransferStatusAndThen, TransferStatus::COMPLETED, - 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, OpenDeviceError::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(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, - base::Bind(&ExpectTransferStatusAndThen, TransferStatus::COMPLETED, - loop.QuitClosure())); - loop.Run(); - } - - EXPECT_CALL(mock_handle(), GenericTransfer(USB_DIRECTION_INBOUND, 0x81, _, - fake_inbound_data.size(), 0, _)); - - { - base::RunLoop loop; - device->GenericTransferIn( - 1, static_cast<uint32_t>(fake_inbound_data.size()), 0, - base::Bind(&ExpectTransferInAndThen, TransferStatus::COMPLETED, - 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, OpenDeviceError::OK, - loop.QuitClosure())); - loop.Run(); - } - - std::vector<UsbDeviceHandle::IsochronousPacket> fake_packets(4); - for (size_t i = 0; i < fake_packets.size(); ++i) { - fake_packets[i].length = 8; - fake_packets[i].transferred_length = 8; - fake_packets[i].status = USB_TRANSFER_COMPLETED; - } - std::vector<uint32_t> fake_packet_lengths(4, 8); - - std::vector<uint32_t> expected_transferred_lengths(4, 8); - - std::string outbound_data = "aaaaaaaabbbbbbbbccccccccdddddddd"; - std::vector<uint8_t> fake_outbound_data(outbound_data.size()); - std::copy(outbound_data.begin(), outbound_data.end(), - fake_outbound_data.begin()); - - std::string inbound_data = "ddddddddccccccccbbbbbbbbaaaaaaaa"; - std::vector<uint8_t> fake_inbound_data(inbound_data.size()); - std::copy(inbound_data.begin(), inbound_data.end(), - fake_inbound_data.begin()); - - AddMockConfig(ConfigBuilder(1).AddInterface(7, 0, 1, 2, 3)); - AddMockOutboundPackets(fake_outbound_data, fake_packets); - AddMockInboundPackets(fake_inbound_data, fake_packets); - - EXPECT_CALL(mock_handle(), - IsochronousTransferOut(0x01, _, fake_packet_lengths, 0, _)); - - { - base::RunLoop loop; - device->IsochronousTransferOut( - 1, mojo::Array<uint8_t>::From(fake_outbound_data), - mojo::Array<uint32_t>::From(fake_packet_lengths), 0, - base::Bind(&ExpectPacketsOutAndThen, expected_transferred_lengths, - loop.QuitClosure())); - loop.Run(); - } - - EXPECT_CALL(mock_handle(), - IsochronousTransferIn(0x81, fake_packet_lengths, 0, _)); - - { - base::RunLoop loop; - device->IsochronousTransferIn( - 1, mojo::Array<uint32_t>::From(fake_packet_lengths), 0, - base::Bind(&ExpectPacketsInAndThen, fake_inbound_data, - expected_transferred_lengths, loop.QuitClosure())); - loop.Run(); - } - - EXPECT_CALL(mock_handle(), Close()); -} - -} // namespace usb -} // namespace device diff --git a/device/devices_app/usb/device_manager_impl.cc b/device/devices_app/usb/device_manager_impl.cc deleted file mode 100644 index b3f7784..0000000 --- a/device/devices_app/usb/device_manager_impl.cc +++ /dev/null @@ -1,228 +0,0 @@ -// 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 "device/devices_app/usb/device_manager_impl.h" - -#include <stddef.h> -#include <utility> - -#include "base/bind.h" -#include "base/location.h" -#include "base/memory/scoped_ptr.h" -#include "base/stl_util.h" -#include "device/core/device_client.h" -#include "device/devices_app/usb/device_impl.h" -#include "device/devices_app/usb/public/interfaces/device.mojom.h" -#include "device/devices_app/usb/type_converters.h" -#include "device/usb/usb_device.h" -#include "device/usb/usb_device_filter.h" -#include "device/usb/usb_service.h" -#include "mojo/public/cpp/bindings/array.h" -#include "mojo/public/cpp/bindings/interface_request.h" - -namespace device { -namespace usb { - -namespace { - -using DeviceList = DeviceManagerImpl::DeviceList; -using DeviceMap = DeviceManagerImpl::DeviceMap; - -void FilterAndConvertDevicesAndThen( - const DeviceMap& devices, - const DeviceManagerImpl::GetDevicesCallback& callback, - mojo::Array<mojo::String> allowed_guids) { - mojo::Array<DeviceInfoPtr> allowed_devices(allowed_guids.size()); - for (size_t i = 0; i < allowed_guids.size(); ++i) { - const auto it = devices.find(allowed_guids[i]); - DCHECK(it != devices.end()); - allowed_devices[i] = DeviceInfo::From(*it->second); - } - - callback.Run(std::move(allowed_devices)); -} - -} // namespace - -// static -void DeviceManagerImpl::Create(PermissionProviderPtr permission_provider, - mojo::InterfaceRequest<DeviceManager> request) { - // The created object is owned by its binding. - new DeviceManagerImpl(std::move(permission_provider), std::move(request)); -} - -DeviceManagerImpl::DeviceManagerImpl( - PermissionProviderPtr permission_provider, - mojo::InterfaceRequest<DeviceManager> request) - : permission_provider_(std::move(permission_provider)), - observer_(this), - binding_(this, std::move(request)), - weak_factory_(this) { - // This object owns itself and will be destroyed if either the message pipe - // it is bound to is closed or the PermissionProvider it depends on is - // unavailable. - binding_.set_connection_error_handler([this]() { delete this; }); - permission_provider_.set_connection_error_handler([this]() { delete this; }); - - DCHECK(DeviceClient::Get()); - usb_service_ = DeviceClient::Get()->GetUsbService(); - if (usb_service_) - observer_.Add(usb_service_); -} - -DeviceManagerImpl::~DeviceManagerImpl() { - connection_error_handler_.Run(); -} - -void DeviceManagerImpl::GetDevices(EnumerationOptionsPtr options, - const GetDevicesCallback& callback) { - if (!usb_service_) { - mojo::Array<DeviceInfoPtr> no_devices; - callback.Run(std::move(no_devices)); - return; - } - - usb_service_->GetDevices(base::Bind(&DeviceManagerImpl::OnGetDevices, - weak_factory_.GetWeakPtr(), - base::Passed(&options), callback)); -} - -void DeviceManagerImpl::GetDeviceChanges( - const GetDeviceChangesCallback& callback) { - device_change_callbacks_.push(callback); - MaybeRunDeviceChangesCallback(); -} - -void DeviceManagerImpl::GetDevice( - const mojo::String& guid, - mojo::InterfaceRequest<Device> device_request) { - if (!usb_service_) - return; - - scoped_refptr<UsbDevice> device = usb_service_->GetDevice(guid); - if (!device) - return; - - mojo::Array<DeviceInfoPtr> requested_devices(1); - requested_devices[0] = DeviceInfo::From(*device); - permission_provider_->HasDevicePermission( - std::move(requested_devices), - base::Bind(&DeviceManagerImpl::OnGetDevicePermissionCheckComplete, - base::Unretained(this), device, - base::Passed(&device_request))); -} - -void DeviceManagerImpl::OnGetDevicePermissionCheckComplete( - scoped_refptr<UsbDevice> device, - mojo::InterfaceRequest<Device> device_request, - mojo::Array<mojo::String> allowed_guids) { - if (allowed_guids.size() == 0) - return; - - DCHECK(allowed_guids.size() == 1); - PermissionProviderPtr permission_provider; - permission_provider_->Bind(mojo::GetProxy(&permission_provider)); - new DeviceImpl(device, std::move(permission_provider), - std::move(device_request)); -} - -void DeviceManagerImpl::OnGetDevices(EnumerationOptionsPtr options, - const GetDevicesCallback& callback, - const DeviceList& devices) { - std::vector<UsbDeviceFilter> filters; - if (options) - filters = options->filters.To<std::vector<UsbDeviceFilter>>(); - - std::map<std::string, scoped_refptr<UsbDevice>> device_map; - mojo::Array<DeviceInfoPtr> requested_devices(0); - for (const auto& device : devices) { - if (filters.empty() || UsbDeviceFilter::MatchesAny(device, filters)) { - device_map[device->guid()] = device; - requested_devices.push_back(DeviceInfo::From(*device)); - } - } - - permission_provider_->HasDevicePermission( - std::move(requested_devices), - base::Bind(&FilterAndConvertDevicesAndThen, device_map, callback)); -} - -void DeviceManagerImpl::OnDeviceAdded(scoped_refptr<UsbDevice> device) { - DCHECK(!ContainsKey(devices_removed_, device->guid())); - devices_added_[device->guid()] = device; - MaybeRunDeviceChangesCallback(); -} - -void DeviceManagerImpl::OnDeviceRemoved(scoped_refptr<UsbDevice> device) { - if (devices_added_.erase(device->guid()) == 0) - devices_removed_[device->guid()] = device; - MaybeRunDeviceChangesCallback(); -} - -void DeviceManagerImpl::WillDestroyUsbService() { - observer_.RemoveAll(); - usb_service_ = nullptr; -} - -void DeviceManagerImpl::MaybeRunDeviceChangesCallback() { - if (!permission_request_pending_ && !device_change_callbacks_.empty()) { - DeviceMap devices_added; - devices_added.swap(devices_added_); - DeviceMap devices_removed; - devices_removed.swap(devices_removed_); - - mojo::Array<DeviceInfoPtr> requested_devices(devices_added.size() + - devices_removed.size()); - { - size_t i = 0; - for (const auto& map_entry : devices_added) - requested_devices[i++] = DeviceInfo::From(*map_entry.second); - for (const auto& map_entry : devices_removed) - requested_devices[i++] = DeviceInfo::From(*map_entry.second); - } - - permission_request_pending_ = true; - permission_provider_->HasDevicePermission( - std::move(requested_devices), - base::Bind(&DeviceManagerImpl::OnEnumerationPermissionCheckComplete, - base::Unretained(this), devices_added, devices_removed)); - } -} - -void DeviceManagerImpl::OnEnumerationPermissionCheckComplete( - const DeviceMap& devices_added, - const DeviceMap& devices_removed, - mojo::Array<mojo::String> allowed_guids) { - permission_request_pending_ = false; - - if (allowed_guids.size() > 0) { - DeviceChangeNotificationPtr notification = DeviceChangeNotification::New(); - notification->devices_added.resize(0); - notification->devices_removed.resize(0); - - for (size_t i = 0; i < allowed_guids.size(); ++i) { - const mojo::String& guid = allowed_guids[i]; - auto it = devices_added.find(guid); - if (it != devices_added.end()) { - DCHECK(!ContainsKey(devices_removed, guid)); - notification->devices_added.push_back(DeviceInfo::From(*it->second)); - } else { - it = devices_removed.find(guid); - DCHECK(it != devices_removed.end()); - notification->devices_removed.push_back(DeviceInfo::From(*it->second)); - } - } - - DCHECK(!device_change_callbacks_.empty()); - const GetDeviceChangesCallback& callback = device_change_callbacks_.front(); - callback.Run(std::move(notification)); - device_change_callbacks_.pop(); - } - - if (devices_added_.size() > 0 || !devices_removed_.empty()) - MaybeRunDeviceChangesCallback(); -} - -} // namespace usb -} // namespace device diff --git a/device/devices_app/usb/device_manager_impl.h b/device/devices_app/usb/device_manager_impl.h deleted file mode 100644 index 4e9578d..0000000 --- a/device/devices_app/usb/device_manager_impl.h +++ /dev/null @@ -1,111 +0,0 @@ -// 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. - -#ifndef DEVICE_USB_DEVICE_MANAGER_IMPL_H_ -#define DEVICE_USB_DEVICE_MANAGER_IMPL_H_ - -#include <queue> -#include <set> - -#include "base/macros.h" -#include "base/memory/ref_counted.h" -#include "base/memory/scoped_ptr.h" -#include "base/memory/weak_ptr.h" -#include "base/scoped_observer.h" -#include "device/devices_app/usb/public/interfaces/device_manager.mojom.h" -#include "device/devices_app/usb/public/interfaces/permission_provider.mojom.h" -#include "device/usb/usb_service.h" -#include "mojo/public/cpp/bindings/array.h" -#include "mojo/public/cpp/bindings/binding.h" -#include "mojo/public/cpp/bindings/interface_request.h" - -namespace base { -class SequencedTaskRunner; -} - -namespace device { - -class UsbDevice; -class UsbDeviceFilter; -class UsbDeviceHandle; - -namespace usb { - -class DeviceManagerDelegate; - -// Implementation of the public DeviceManager interface. This interface can be -// requested from the devices app located at "mojo:devices", if available. -class DeviceManagerImpl : public DeviceManager, - public device::UsbService::Observer { - public: - using DeviceList = std::vector<scoped_refptr<UsbDevice>>; - using DeviceMap = std::map<std::string, scoped_refptr<device::UsbDevice>>; - - static void Create(PermissionProviderPtr permission_provider, - mojo::InterfaceRequest<DeviceManager> request); - - DeviceManagerImpl(PermissionProviderPtr permission_provider, - mojo::InterfaceRequest<DeviceManager> request); - ~DeviceManagerImpl() override; - - void set_connection_error_handler(const mojo::Closure& error_handler) { - connection_error_handler_ = error_handler; - } - - private: - // DeviceManager implementation: - void GetDevices(EnumerationOptionsPtr options, - const GetDevicesCallback& callback) override; - void GetDeviceChanges(const GetDeviceChangesCallback& callback) override; - void GetDevice(const mojo::String& guid, - mojo::InterfaceRequest<Device> device_request) override; - - // Callbacks to handle the async responses from the underlying UsbService. - void OnGetDevicePermissionCheckComplete( - scoped_refptr<device::UsbDevice> device, - mojo::InterfaceRequest<Device> device_request, - mojo::Array<mojo::String> allowed_guids); - void OnGetDevices(EnumerationOptionsPtr options, - const GetDevicesCallback& callback, - const DeviceList& devices); - - // UsbService::Observer implementation: - void OnDeviceAdded(scoped_refptr<device::UsbDevice> device) override; - void OnDeviceRemoved(scoped_refptr<device::UsbDevice> device) override; - void WillDestroyUsbService() override; - - void MaybeRunDeviceChangesCallback(); - void OnEnumerationPermissionCheckComplete( - const DeviceMap& devices_added, - const DeviceMap& devices_removed, - mojo::Array<mojo::String> allowed_guids); - - PermissionProviderPtr permission_provider_; - - // If there are unfinished calls to GetDeviceChanges their callbacks - // are stored in |device_change_callbacks_|. Otherwise device changes - // are collected in |devices_added_| and |devices_removed_| until the - // next call to GetDeviceChanges. - std::queue<GetDeviceChangesCallback> device_change_callbacks_; - DeviceMap devices_added_; - DeviceMap devices_removed_; - // To ensure that GetDeviceChangesCallbacks are called in the correct order - // only perform a single request to |permission_provider_| at a time. - bool permission_request_pending_ = false; - - UsbService* usb_service_; - ScopedObserver<device::UsbService, device::UsbService::Observer> observer_; - - mojo::Closure connection_error_handler_; - - mojo::Binding<DeviceManager> binding_; - base::WeakPtrFactory<DeviceManagerImpl> weak_factory_; - - DISALLOW_COPY_AND_ASSIGN(DeviceManagerImpl); -}; - -} // namespace usb -} // namespace device - -#endif // DEVICE_USB_DEVICE_MANAGER_IMPL_H_ diff --git a/device/devices_app/usb/device_manager_impl_unittest.cc b/device/devices_app/usb/device_manager_impl_unittest.cc deleted file mode 100644 index 720c811..0000000 --- a/device/devices_app/usb/device_manager_impl_unittest.cc +++ /dev/null @@ -1,218 +0,0 @@ -// 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 "device/devices_app/usb/device_manager_impl.h" - -#include <stddef.h> -#include <set> -#include <string> -#include <utility> - -#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/mock_device_client.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 "device/usb/mock_usb_service.h" -#include "testing/gtest/include/gtest/gtest.h" - -using ::testing::Invoke; -using ::testing::_; - -namespace device { -namespace usb { - -namespace { - -class USBDeviceManagerImplTest : public testing::Test { - public: - USBDeviceManagerImplTest() : message_loop_(new base::MessageLoop) {} - ~USBDeviceManagerImplTest() override {} - - protected: - DeviceManagerPtr ConnectToDeviceManager() { - PermissionProviderPtr permission_provider; - permission_provider_.Bind(mojo::GetProxy(&permission_provider)); - DeviceManagerPtr device_manager; - DeviceManagerImpl::Create(std::move(permission_provider), - mojo::GetProxy(&device_manager)); - return device_manager; - } - - MockDeviceClient device_client_; - - private: - FakePermissionProvider permission_provider_; - scoped_ptr<base::MessageLoop> message_loop_; -}; - -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(); -} - -void ExpectDeviceChangesAndThen( - const std::set<std::string>& expected_added_guids, - const std::set<std::string>& expected_removed_guids, - const base::Closure& continuation, - DeviceChangeNotificationPtr results) { - EXPECT_EQ(expected_added_guids.size(), results->devices_added.size()); - std::set<std::string> actual_added_guids; - for (size_t i = 0; i < results->devices_added.size(); ++i) - actual_added_guids.insert(results->devices_added[i]->guid); - EXPECT_EQ(expected_added_guids, actual_added_guids); - EXPECT_EQ(expected_removed_guids.size(), results->devices_removed.size()); - 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(); -} - -} // 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 = - new MockUsbDevice(0x1234, 0x567a, "ACME", "Frobinator Mk II", "MNOPQR"); - - device_client_.usb_service()->AddDevice(device0); - device_client_.usb_service()->AddDevice(device1); - device_client_.usb_service()->AddDevice(device2); - - DeviceManagerPtr device_manager = ConnectToDeviceManager(); - - 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()); - guids.insert(device2->guid()); - - base::RunLoop loop; - device_manager->GetDevices( - std::move(options), - base::Bind(&ExpectDevicesAndThen, guids, loop.QuitClosure())); - loop.Run(); -} - -// Test requesting a single Device by GUID. -TEST_F(USBDeviceManagerImplTest, GetDevice) { - scoped_refptr<MockUsbDevice> mock_device = - new MockUsbDevice(0x1234, 0x5678, "ACME", "Frobinator", "ABCDEF"); - - device_client_.usb_service()->AddDevice(mock_device); - - DeviceManagerPtr device_manager = ConnectToDeviceManager(); - - { - base::RunLoop loop; - DevicePtr device; - device_manager->GetDevice(mock_device->guid(), mojo::GetProxy(&device)); - device->GetDeviceInfo(base::Bind(&ExpectDeviceInfoAndThen, - mock_device->guid(), loop.QuitClosure())); - loop.Run(); - } - - DevicePtr bad_device; - device_manager->GetDevice("not a real guid", mojo::GetProxy(&bad_device)); - - { - base::RunLoop loop; - bad_device.set_connection_error_handler(loop.QuitClosure()); - 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"); - scoped_refptr<MockUsbDevice> device2 = - new MockUsbDevice(0x1234, 0x567a, "ACME", "Frobinator Mk II", "MNOPQR"); - scoped_refptr<MockUsbDevice> device3 = - new MockUsbDevice(0x1234, 0x567b, "ACME", "Frobinator Xtreme", "STUVWX"); - - device_client_.usb_service()->AddDevice(device0); - - DeviceManagerPtr device_manager = ConnectToDeviceManager(); - - { - // Call GetDevices once to make sure the device manager is up and running - // or else we could end up waiting forever for device changes as the next - // block races with the ServiceThreadHelper startup. - std::set<std::string> guids; - guids.insert(device0->guid()); - base::RunLoop loop; - device_manager->GetDevices( - nullptr, base::Bind(&ExpectDevicesAndThen, guids, loop.QuitClosure())); - loop.Run(); - } - - device_client_.usb_service()->AddDevice(device1); - device_client_.usb_service()->AddDevice(device2); - device_client_.usb_service()->RemoveDevice(device1); - - { - std::set<std::string> added_guids; - std::set<std::string> removed_guids; - added_guids.insert(device2->guid()); - base::RunLoop loop; - device_manager->GetDeviceChanges(base::Bind(&ExpectDeviceChangesAndThen, - added_guids, removed_guids, - loop.QuitClosure())); - loop.Run(); - } - - device_client_.usb_service()->RemoveDevice(device0); - device_client_.usb_service()->RemoveDevice(device2); - device_client_.usb_service()->AddDevice(device3); - - { - std::set<std::string> added_guids; - std::set<std::string> removed_guids; - added_guids.insert(device3->guid()); - removed_guids.insert(device0->guid()); - removed_guids.insert(device2->guid()); - base::RunLoop loop; - device_manager->GetDeviceChanges(base::Bind(&ExpectDeviceChangesAndThen, - added_guids, removed_guids, - loop.QuitClosure())); - loop.Run(); - } -} - -} // namespace usb -} // namespace device diff --git a/device/devices_app/usb/fake_permission_provider.cc b/device/devices_app/usb/fake_permission_provider.cc deleted file mode 100644 index 3a774a8..0000000 --- a/device/devices_app/usb/fake_permission_provider.cc +++ /dev/null @@ -1,46 +0,0 @@ -// 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 "device/devices_app/usb/fake_permission_provider.h" - -#include <stddef.h> -#include <utility> - -namespace device { -namespace usb { - -FakePermissionProvider::FakePermissionProvider() {} - -FakePermissionProvider::~FakePermissionProvider() {} - -void FakePermissionProvider::HasDevicePermission( - mojo::Array<DeviceInfoPtr> requested_devices, - const HasDevicePermissionCallback& callback) { - mojo::Array<mojo::String> allowed_guids(requested_devices.size()); - for (size_t i = 0; i < requested_devices.size(); ++i) - allowed_guids[i] = requested_devices[i]->guid; - callback.Run(std::move(allowed_guids)); -} - -void FakePermissionProvider::HasConfigurationPermission( - uint8_t requested_configuration, - device::usb::DeviceInfoPtr device, - const HasInterfacePermissionCallback& callback) { - callback.Run(true); -} -void FakePermissionProvider::HasInterfacePermission( - uint8_t requested_interface, - uint8_t configuration_value, - device::usb::DeviceInfoPtr device, - const HasInterfacePermissionCallback& callback) { - callback.Run(true); -} - -void FakePermissionProvider::Bind( - mojo::InterfaceRequest<PermissionProvider> request) { - bindings_.AddBinding(this, std::move(request)); -} - -} // namespace usb -} // namespace device diff --git a/device/devices_app/usb/fake_permission_provider.h b/device/devices_app/usb/fake_permission_provider.h deleted file mode 100644 index 62947b4..0000000 --- a/device/devices_app/usb/fake_permission_provider.h +++ /dev/null @@ -1,44 +0,0 @@ -// 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. - -#ifndef DEVICE_USB_FAKE_PERMISSION_PROVIDER_H_ -#define DEVICE_USB_FAKE_PERMISSION_PROVIDER_H_ - -#include <stdint.h> - -#include "device/devices_app/usb/public/interfaces/permission_provider.mojom.h" -#include "mojo/common/weak_binding_set.h" -#include "mojo/public/cpp/bindings/array.h" -#include "mojo/public/cpp/bindings/interface_request.h" - -namespace device { -namespace usb { - -class FakePermissionProvider : public PermissionProvider { - public: - FakePermissionProvider(); - ~FakePermissionProvider() override; - - void HasDevicePermission( - mojo::Array<DeviceInfoPtr> requested_devices, - const HasDevicePermissionCallback& callback) override; - void HasConfigurationPermission( - uint8_t requested_configuration, - device::usb::DeviceInfoPtr device, - const HasInterfacePermissionCallback& callback) override; - void HasInterfacePermission( - uint8_t requested_interface, - uint8_t configuration_value, - device::usb::DeviceInfoPtr device, - const HasInterfacePermissionCallback& callback) override; - void Bind(mojo::InterfaceRequest<PermissionProvider> request) override; - - private: - mojo::WeakBindingSet<PermissionProvider> bindings_; -}; - -} // namespace usb -} // namespace device - -#endif // DEVICE_USB_FAKE_PERMISSION_PROVIDER_H_ diff --git a/device/devices_app/usb/public/interfaces/BUILD.gn b/device/devices_app/usb/public/interfaces/BUILD.gn deleted file mode 100644 index f9d6e0c..0000000 --- a/device/devices_app/usb/public/interfaces/BUILD.gn +++ /dev/null @@ -1,13 +0,0 @@ -# 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. - -import("//mojo/public/tools/bindings/mojom.gni") - -mojom("interfaces") { - sources = [ - "device.mojom", - "device_manager.mojom", - "permission_provider.mojom", - ] -} diff --git a/device/devices_app/usb/public/interfaces/device.mojom b/device/devices_app/usb/public/interfaces/device.mojom deleted file mode 100644 index 25addb2..0000000 --- a/device/devices_app/usb/public/interfaces/device.mojom +++ /dev/null @@ -1,285 +0,0 @@ -// 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. - -module device.usb; - -enum OpenDeviceError { - // Opening the device succeeded. - OK, - - // The operating system denied access to the device. - ACCESS_DENIED, -}; - -enum TransferDirection { - INBOUND, - OUTBOUND, -}; - -enum ControlTransferType { - STANDARD, - CLASS, - VENDOR, - RESERVED -}; - -enum ControlTransferRecipient { - DEVICE, - INTERFACE, - ENDPOINT, - OTHER -}; - -enum EndpointType { - BULK, - INTERRUPT, - ISOCHRONOUS, -}; - -struct EndpointInfo { - uint8 endpoint_number; - TransferDirection direction; - EndpointType type; - uint32 packet_size; -}; - -struct AlternateInterfaceInfo { - uint8 alternate_setting; - uint8 class_code; - uint8 subclass_code; - uint8 protocol_code; - string? interface_name; - array<EndpointInfo> endpoints; -}; - -struct InterfaceInfo { - uint8 interface_number; - array<AlternateInterfaceInfo> alternates; -}; - -struct ConfigurationInfo { - uint8 configuration_value; - string? configuration_name; - array<InterfaceInfo> interfaces; -}; - -struct WebUsbFunctionSubset { - uint8 first_interface; - array<string> origins; -}; - -struct WebUsbConfigurationSubset { - uint8 configuration_value; - array<string> origins; - array<WebUsbFunctionSubset> functions; -}; - -struct WebUsbDescriptorSet { - array<string> origins; - array<WebUsbConfigurationSubset> configurations; -}; - -struct DeviceInfo { - string guid; - uint8 usb_version_major; - uint8 usb_version_minor; - uint8 usb_version_subminor; - uint8 class_code; - uint8 subclass_code; - uint8 protocol_code; - uint16 vendor_id; - uint16 product_id; - uint8 device_version_major; - uint8 device_version_minor; - uint8 device_version_subminor; - string? manufacturer_name; - string? product_name; - string? serial_number; - array<ConfigurationInfo> configurations; - WebUsbDescriptorSet? webusb_allowed_origins; -}; - -struct ControlTransferParams { - ControlTransferType type; - ControlTransferRecipient recipient; - uint8 request; - uint16 value; - uint16 index; -}; - -enum TransferStatus { - // The transfer completed successfully. - COMPLETED, - - // The transfer failed due to a non-specific error. - TRANSFER_ERROR, - - // The transfer was not allowed. - PERMISSION_DENIED, - - // The transfer timed out. - TIMEOUT, - - // The transfer was cancelled. - CANCELLED, - - // The transfer stalled. - STALLED, - - // The transfer failed because the device was disconnected from the host. - DISCONNECT, - - // The transfer succeeded, but the device sent more data than was requested. - // This applies only to inbound transfers. - BABBLE, - - // The transfer succeeded, but the device sent less data than was requested. - // This applies only to inbound transfers. - SHORT_PACKET, -}; - -struct IsochronousPacket { - uint32 length; - uint32 transferred_length; - TransferStatus status; -}; - -interface Device { - // Retrieve a DeviceInfo struct containing metadata about the device, - // including the set of all available device configurations. - GetDeviceInfo() => (DeviceInfo? info); - - // Retrieves the |configuration_value| of the device's currently active - // configuration. Will return 0 if the device is unconfigured. - GetConfiguration() => (uint8 value); - - // Opens the device. Methods below require the device be opened first. - Open() => (OpenDeviceError error); - - // Closes the device. - Close() => (); - - // Initiates a device control transfer to set the device's configuration to - // one with the configuration value |value|. - SetConfiguration(uint8 value) => (bool success); - - // Claims a single interface in the current device configuration. - ClaimInterface(uint8 interface_number) => (bool success); - - // Releases a claimed interface in the current device configuration. - ReleaseInterface(uint8 interface_number) => (bool success); - - // Selects an alternate setting for a given claimed interface. - SetInterfaceAlternateSetting(uint8 interface_number, uint8 alternate_setting) - => (bool success); - - // Resets the device. - Reset() => (bool success); - - // Clear the halt/stall condition for an endpoint. - ClearHalt(uint8 endpoint) => (bool success); - - // Initiates an inbound control transfer request. |params| determine the - // details of the request. Transfers to recipients other than DEVICE require a - // corresponding interface to be claimed. - // - // |length| specifies the expected number of bytes to receive for this - // transfer. The size of |data| will never exceed |length|, and |data| will be - // null if |status| is neither COMPLETED, BABBLE, or SHORT_PACKET. - // - // |timeout| specifies the request timeout in milliseconds. A timeout of 0 - // indicates no timeout: the request will remain pending indefinitely until - // completed or otherwise terminated. - ControlTransferIn(ControlTransferParams params, uint32 length, uint32 timeout) - => (TransferStatus status, array<uint8>? data); - - // Initiates an inbound control transfer request. |params| determine the - // details of the request. Transfers to recipients other than DEVICE require a - // corresponding interface to be claimed. - // - // |data| specifies the bytes to send the device in the body of the request. - // - // |timeout| specifies the request timeout in milliseconds. A timeout of 0 - // indicates no timeout: the request will remain pending indefinitely until - // completed or otherwise terminated. - ControlTransferOut(ControlTransferParams params, - array<uint8> data, - uint32 timeout) - => (TransferStatus status); - - // Initiates an inbound generic transfer request on a specific endpoint. The - // interface to which |endpoint_number| belongs must be claimed, and the - // appropriate alternate setting must be set on that interface before - // transfers can be initiated on the endpoint. The endpoint must be of type - // BULK or INTERRUPT. - // - // |length| specifies the expected number of bytes to receive for this - // transfer. The size of |data| will never exceed |length|, and |data| will be - // null if |status| is neither COMPLETED, BABBLE, or SHORT_PACKET. - // - // |timeout| specifies the request timeout in milliseconds. A timeout of 0 - // indicates no timeout: the request will remain pending indefinitely until - // completed or otherwise terminated. - GenericTransferIn(uint8 endpoint_number, uint32 length, uint32 timeout) - => (TransferStatus status, array<uint8>? data); - - // Initiates an outbound generic transfer request on a specific endpoint. The - // interface to which |endpoint_number| belongs must be claimed, and the - // appropriate alternate setting must be set on that interface before - // transfers can be initiated on the endpoint. The endpoint must be of type - // BULK or INTERRUPT. - // - // |data| specifies the bytes to send the device in the body of the request. - // - // |timeout| specifies the request timeout in milliseconds. A timeout of 0 - // indicates no timeout: the request will remain pending indefinitely until - // completed or otherwise terminated. - GenericTransferOut(uint8 endpoint_number, array<uint8> data, uint32 timeout) - => (TransferStatus status); - - // Initiates an inbound isochronous transfer request on a specific endpoint. - // The interface to which |endpoint_number| belongs must be claimed, and the - // appropriate alternate setting must be set on that interface before - // transfers can be initiated on the endpoint. The endpoint must be of type - // ISOCHRONOUS. - // - // |packet_lengths| specifies the maximum expected number of bytes to receive - // for each packet in this transfer. - // - // |timeout| specifies the request timeout in milliseconds. A timeout of 0 - // indicates no timeout: the request will remain pending indefinitely until - // completed or otherwise terminated. - // - // |data| contains the data received from the device, if any. |packets| - // contains the status of each packet received from the device, in order. The - // length of the packet indicates its position in |data| while it's - // transferred length gives the amount of data actually received from the - // device. - IsochronousTransferIn(uint8 endpoint_number, - array<uint32> packet_lengths, - uint32 timeout) - => (array<uint8>? data, array<IsochronousPacket> packets); - - // Initiates an outbound isochronous transfer request on a specific endpoint. - // The interface to which |endpoint_number| belongs must be claimed, and the - // appropriate alternate setting must be set on that interface before - // transfers can be initiated on the endpoint. The endpoint must be of type - // ISOCHRONOUS. - // - // |data| specifies the bytes to send to the device. - // - // |packet_lengths| specifies how |data| should be separated into packets when - // it is sent to the device. - // - // |timeout| specifies the request timeout in milliseconds. A timeout of 0 - // indicates no timeout: the request will remain pending indefinitely until - // completed or otherwise terminated. - - // |packets| contains the status of each packet sent to the device, in order. - IsochronousTransferOut(uint8 endpoint_number, - array<uint8> data, - array<uint32> packet_lengths, - uint32 timeout) - => (array<IsochronousPacket> packets); -}; diff --git a/device/devices_app/usb/public/interfaces/device_manager.mojom b/device/devices_app/usb/public/interfaces/device_manager.mojom deleted file mode 100644 index fa8bb75..0000000 --- a/device/devices_app/usb/public/interfaces/device_manager.mojom +++ /dev/null @@ -1,47 +0,0 @@ -// 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. - -module device.usb; - -import "device.mojom"; - -struct DeviceFilter { - bool has_vendor_id; - uint16 vendor_id; - - bool has_product_id; - uint16 product_id; - - bool has_class_code; - uint8 class_code; - - bool has_subclass_code; - uint8 subclass_code; - - bool has_protocol_code; - uint8 protocol_code; -}; - -struct EnumerationOptions { - array<DeviceFilter>? filters; -}; - -struct DeviceChangeNotification { - array<DeviceInfo> devices_added; - array<DeviceInfo> devices_removed; -}; - -interface DeviceManager { - // Retrieves information about all devices available to the DeviceManager - // implementation. - GetDevices(EnumerationOptions? options) => (array<DeviceInfo> results); - - // Retrieves information about changes to the set of devices available to the - // DeviceManager since the last call to this method. A device that is added - // and removed between calls will not be included. - GetDeviceChanges() => (DeviceChangeNotification changes); - - // Requests a device by guid. - GetDevice(string guid, Device& device_request); -}; diff --git a/device/devices_app/usb/public/interfaces/permission_provider.mojom b/device/devices_app/usb/public/interfaces/permission_provider.mojom deleted file mode 100644 index f5d7111..0000000 --- a/device/devices_app/usb/public/interfaces/permission_provider.mojom +++ /dev/null @@ -1,29 +0,0 @@ -// 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. - -module device.usb; - -import "device.mojom"; - -interface PermissionProvider { - // Filters a set of |requested_devices| down to the set of |allowed_guids| - // that should be accessible to clients of the DeviceManager instance. - HasDevicePermission(array<DeviceInfo> requested_devices) - => (array<string> allowed_guids); - - // Returns whether or not the client has permission to access - // |requested_configuration| on |device|. - HasConfigurationPermission(uint8 requested_configuration, - DeviceInfo device) => (bool allowed); - - // Returns whether or not the client has permission to access - // |requested_interface| on |device| when it is in configuration - // |configuration_value|. - HasInterfacePermission(uint8 requested_interface, - uint8 configuration_value, - DeviceInfo device) => (bool allowed); - - // Requests a new binding to this service. - Bind(PermissionProvider& request); -}; diff --git a/device/devices_app/usb/type_converters.cc b/device/devices_app/usb/type_converters.cc deleted file mode 100644 index 709b0ca..0000000 --- a/device/devices_app/usb/type_converters.cc +++ /dev/null @@ -1,283 +0,0 @@ -// 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 "device/devices_app/usb/type_converters.h" - -#include <stddef.h> -#include <stdint.h> - -#include <map> -#include <utility> - -#include "base/logging.h" -#include "base/strings/utf_string_conversions.h" -#include "device/usb/usb_device.h" -#include "mojo/common/url_type_converters.h" -#include "mojo/public/cpp/bindings/array.h" - -namespace mojo { - -// static -device::UsbDeviceFilter -TypeConverter<device::UsbDeviceFilter, device::usb::DeviceFilterPtr>::Convert( - const device::usb::DeviceFilterPtr& mojo_filter) { - device::UsbDeviceFilter filter; - if (mojo_filter->has_vendor_id) - filter.SetVendorId(mojo_filter->vendor_id); - if (mojo_filter->has_product_id) - filter.SetProductId(mojo_filter->product_id); - if (mojo_filter->has_class_code) - filter.SetInterfaceClass(mojo_filter->class_code); - if (mojo_filter->has_subclass_code) - filter.SetInterfaceSubclass(mojo_filter->subclass_code); - if (mojo_filter->has_protocol_code) - filter.SetInterfaceProtocol(mojo_filter->protocol_code); - return filter; -} - -// static -device::usb::TransferDirection -TypeConverter<device::usb::TransferDirection, device::UsbEndpointDirection>:: - Convert(const device::UsbEndpointDirection& direction) { - if (direction == device::USB_DIRECTION_INBOUND) - return device::usb::TransferDirection::INBOUND; - DCHECK(direction == device::USB_DIRECTION_OUTBOUND); - return device::usb::TransferDirection::OUTBOUND; -} - -// static -device::usb::TransferStatus -TypeConverter<device::usb::TransferStatus, device::UsbTransferStatus>::Convert( - const device::UsbTransferStatus& status) { - switch (status) { - case device::USB_TRANSFER_COMPLETED: - return device::usb::TransferStatus::COMPLETED; - case device::USB_TRANSFER_ERROR: - return device::usb::TransferStatus::TRANSFER_ERROR; - case device::USB_TRANSFER_TIMEOUT: - return device::usb::TransferStatus::TIMEOUT; - case device::USB_TRANSFER_CANCELLED: - return device::usb::TransferStatus::CANCELLED; - case device::USB_TRANSFER_STALLED: - return device::usb::TransferStatus::STALLED; - case device::USB_TRANSFER_DISCONNECT: - return device::usb::TransferStatus::DISCONNECT; - case device::USB_TRANSFER_OVERFLOW: - return device::usb::TransferStatus::BABBLE; - case device::USB_TRANSFER_LENGTH_SHORT: - return device::usb::TransferStatus::SHORT_PACKET; - default: - NOTREACHED(); - return device::usb::TransferStatus::TRANSFER_ERROR; - } -} - -// static -device::UsbDeviceHandle::TransferRequestType -TypeConverter<device::UsbDeviceHandle::TransferRequestType, - device::usb::ControlTransferType>:: - Convert(const device::usb::ControlTransferType& type) { - switch (type) { - case device::usb::ControlTransferType::STANDARD: - return device::UsbDeviceHandle::STANDARD; - case device::usb::ControlTransferType::CLASS: - return device::UsbDeviceHandle::CLASS; - case device::usb::ControlTransferType::VENDOR: - return device::UsbDeviceHandle::VENDOR; - case device::usb::ControlTransferType::RESERVED: - return device::UsbDeviceHandle::RESERVED; - default: - NOTREACHED(); - return device::UsbDeviceHandle::RESERVED; - } -} - -// static -device::UsbDeviceHandle::TransferRecipient -TypeConverter<device::UsbDeviceHandle::TransferRecipient, - device::usb::ControlTransferRecipient>:: - Convert(const device::usb::ControlTransferRecipient& recipient) { - switch (recipient) { - case device::usb::ControlTransferRecipient::DEVICE: - return device::UsbDeviceHandle::DEVICE; - case device::usb::ControlTransferRecipient::INTERFACE: - return device::UsbDeviceHandle::INTERFACE; - case device::usb::ControlTransferRecipient::ENDPOINT: - return device::UsbDeviceHandle::ENDPOINT; - case device::usb::ControlTransferRecipient::OTHER: - return device::UsbDeviceHandle::OTHER; - default: - NOTREACHED(); - return device::UsbDeviceHandle::OTHER; - } -} - -// static -device::usb::EndpointType -TypeConverter<device::usb::EndpointType, device::UsbTransferType>::Convert( - const device::UsbTransferType& type) { - switch (type) { - case device::USB_TRANSFER_ISOCHRONOUS: - return device::usb::EndpointType::ISOCHRONOUS; - case device::USB_TRANSFER_BULK: - return device::usb::EndpointType::BULK; - case device::USB_TRANSFER_INTERRUPT: - return device::usb::EndpointType::INTERRUPT; - // Note that we do not expose control transfer in the public interface - // because control endpoints are implied rather than explicitly enumerated - // there. - default: - NOTREACHED(); - return device::usb::EndpointType::BULK; - } -} - -// static -device::usb::EndpointInfoPtr -TypeConverter<device::usb::EndpointInfoPtr, device::UsbEndpointDescriptor>:: - Convert(const device::UsbEndpointDescriptor& endpoint) { - device::usb::EndpointInfoPtr info = device::usb::EndpointInfo::New(); - info->endpoint_number = endpoint.address; - info->direction = - ConvertTo<device::usb::TransferDirection>(endpoint.direction); - info->type = ConvertTo<device::usb::EndpointType>(endpoint.transfer_type); - info->packet_size = static_cast<uint32_t>(endpoint.maximum_packet_size); - return info; -} - -// static -device::usb::AlternateInterfaceInfoPtr -TypeConverter<device::usb::AlternateInterfaceInfoPtr, - device::UsbInterfaceDescriptor>:: - Convert(const device::UsbInterfaceDescriptor& interface) { - device::usb::AlternateInterfaceInfoPtr info = - device::usb::AlternateInterfaceInfo::New(); - info->alternate_setting = interface.alternate_setting; - info->class_code = interface.interface_class; - info->subclass_code = interface.interface_subclass; - info->protocol_code = interface.interface_protocol; - - // Filter out control endpoints for the public interface. - info->endpoints = mojo::Array<device::usb::EndpointInfoPtr>::New(0); - for (const auto& endpoint : interface.endpoints) { - if (endpoint.transfer_type != device::USB_TRANSFER_CONTROL) - info->endpoints.push_back(device::usb::EndpointInfo::From(endpoint)); - } - - return info; -} - -// static -mojo::Array<device::usb::InterfaceInfoPtr> -TypeConverter<mojo::Array<device::usb::InterfaceInfoPtr>, - std::vector<device::UsbInterfaceDescriptor>>:: - Convert(const std::vector<device::UsbInterfaceDescriptor>& interfaces) { - auto infos = mojo::Array<device::usb::InterfaceInfoPtr>::New(0); - - // Aggregate each alternate setting into an InterfaceInfo corresponding to its - // interface number. - std::map<uint8_t, device::usb::InterfaceInfo*> interface_map; - for (size_t i = 0; i < interfaces.size(); ++i) { - auto alternate = device::usb::AlternateInterfaceInfo::From(interfaces[i]); - auto iter = interface_map.find(interfaces[i].interface_number); - if (iter == interface_map.end()) { - // This is the first time we're seeing an alternate with this interface - // number, so add a new InterfaceInfo to the array and map the number. - auto info = device::usb::InterfaceInfo::New(); - iter = interface_map.insert(std::make_pair(interfaces[i].interface_number, - info.get())).first; - infos.push_back(std::move(info)); - } - iter->second->alternates.push_back(std::move(alternate)); - } - - return infos; -} - -// static -device::usb::ConfigurationInfoPtr -TypeConverter<device::usb::ConfigurationInfoPtr, device::UsbConfigDescriptor>:: - Convert(const device::UsbConfigDescriptor& config) { - device::usb::ConfigurationInfoPtr info = - device::usb::ConfigurationInfo::New(); - info->configuration_value = config.configuration_value; - info->interfaces = - mojo::Array<device::usb::InterfaceInfoPtr>::From(config.interfaces); - return info; -} - -// static -device::usb::WebUsbFunctionSubsetPtr TypeConverter< - device::usb::WebUsbFunctionSubsetPtr, - device::WebUsbFunctionSubset>::Convert(const device::WebUsbFunctionSubset& - function) { - device::usb::WebUsbFunctionSubsetPtr info = - device::usb::WebUsbFunctionSubset::New(); - info->first_interface = function.first_interface; - info->origins = mojo::Array<mojo::String>::From(function.origins); - return info; -} - -// static -device::usb::WebUsbConfigurationSubsetPtr -TypeConverter<device::usb::WebUsbConfigurationSubsetPtr, - device::WebUsbConfigurationSubset>:: - Convert(const device::WebUsbConfigurationSubset& config) { - device::usb::WebUsbConfigurationSubsetPtr info = - device::usb::WebUsbConfigurationSubset::New(); - info->configuration_value = config.configuration_value; - info->origins = mojo::Array<mojo::String>::From(config.origins); - info->functions = - mojo::Array<device::usb::WebUsbFunctionSubsetPtr>::From(config.functions); - return info; -} - -// static -device::usb::WebUsbDescriptorSetPtr TypeConverter< - device::usb::WebUsbDescriptorSetPtr, - device::WebUsbAllowedOrigins>::Convert(const device::WebUsbAllowedOrigins& - allowed_origins) { - device::usb::WebUsbDescriptorSetPtr info = - device::usb::WebUsbDescriptorSet::New(); - info->origins = mojo::Array<mojo::String>::From(allowed_origins.origins); - info->configurations = - mojo::Array<device::usb::WebUsbConfigurationSubsetPtr>::From( - allowed_origins.configurations); - return info; -} - -// static -device::usb::DeviceInfoPtr -TypeConverter<device::usb::DeviceInfoPtr, device::UsbDevice>::Convert( - const device::UsbDevice& device) { - device::usb::DeviceInfoPtr info = device::usb::DeviceInfo::New(); - info->guid = device.guid(); - info->vendor_id = device.vendor_id(); - info->product_id = device.product_id(); - info->manufacturer_name = base::UTF16ToUTF8(device.manufacturer_string()); - info->product_name = base::UTF16ToUTF8(device.product_string()); - info->serial_number = base::UTF16ToUTF8(device.serial_number()); - info->configurations = mojo::Array<device::usb::ConfigurationInfoPtr>::From( - device.configurations()); - if (device.webusb_allowed_origins()) { - info->webusb_allowed_origins = device::usb::WebUsbDescriptorSet::From( - *device.webusb_allowed_origins()); - } - return info; -} - -// static -device::usb::IsochronousPacketPtr -TypeConverter<device::usb::IsochronousPacketPtr, - device::UsbDeviceHandle::IsochronousPacket>:: - Convert(const device::UsbDeviceHandle::IsochronousPacket& packet) { - device::usb::IsochronousPacketPtr info = - device::usb::IsochronousPacket::New(); - info->length = packet.length; - info->transferred_length = packet.transferred_length; - info->status = mojo::ConvertTo<device::usb::TransferStatus>(packet.status); - return info; -} - -} // namespace mojo diff --git a/device/devices_app/usb/type_converters.h b/device/devices_app/usb/type_converters.h deleted file mode 100644 index 15484ea..0000000 --- a/device/devices_app/usb/type_converters.h +++ /dev/null @@ -1,134 +0,0 @@ -// 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. - -#ifndef DEVICE_DEVICES_APP_USB_TYPE_CONVERTERS_H_ -#define DEVICE_DEVICES_APP_USB_TYPE_CONVERTERS_H_ - -#include <vector> - -#include "device/devices_app/usb/public/interfaces/device.mojom.h" -#include "device/devices_app/usb/public/interfaces/device_manager.mojom.h" -#include "device/usb/usb_descriptors.h" -#include "device/usb/usb_device_filter.h" -#include "device/usb/usb_device_handle.h" -#include "device/usb/webusb_descriptors.h" -#include "mojo/public/cpp/bindings/array.h" -#include "mojo/public/cpp/bindings/type_converter.h" - -// Type converters to translate between internal device/usb data types and -// public Mojo interface data types. This must be included by any source file -// that uses these conversions explicitly or implicitly. - -namespace device { -class UsbDevice; -} - -namespace mojo { - -template <> -struct TypeConverter<device::UsbDeviceFilter, device::usb::DeviceFilterPtr> { - static device::UsbDeviceFilter Convert( - const device::usb::DeviceFilterPtr& mojo_filter); -}; - -template <> -struct TypeConverter<device::usb::TransferDirection, - device::UsbEndpointDirection> { - static device::usb::TransferDirection Convert( - const device::UsbEndpointDirection& direction); -}; - -template <> -struct TypeConverter<device::usb::TransferStatus, device::UsbTransferStatus> { - static device::usb::TransferStatus Convert( - const device::UsbTransferStatus& status); -}; - -template <> -struct TypeConverter<device::UsbDeviceHandle::TransferRequestType, - device::usb::ControlTransferType> { - static device::UsbDeviceHandle::TransferRequestType Convert( - const device::usb::ControlTransferType& type); -}; - -template <> -struct TypeConverter<device::UsbDeviceHandle::TransferRecipient, - device::usb::ControlTransferRecipient> { - static device::UsbDeviceHandle::TransferRecipient Convert( - const device::usb::ControlTransferRecipient& recipient); -}; - -template <> -struct TypeConverter<device::usb::EndpointType, device::UsbTransferType> { - static device::usb::EndpointType Convert(const device::UsbTransferType& type); -}; - -template <> -struct TypeConverter<device::usb::EndpointInfoPtr, - device::UsbEndpointDescriptor> { - static device::usb::EndpointInfoPtr Convert( - const device::UsbEndpointDescriptor& endpoint); -}; - -template <> -struct TypeConverter<device::usb::AlternateInterfaceInfoPtr, - device::UsbInterfaceDescriptor> { - static device::usb::AlternateInterfaceInfoPtr Convert( - const device::UsbInterfaceDescriptor& interface); -}; - -// Note that this is an explicit vector-to-array conversion, as -// UsbInterfaceDescriptor collections are flattened to contain all alternate -// settings, whereas InterfaceInfos contain their own sets of alternates with -// a different structure type. -template <> -struct TypeConverter<mojo::Array<device::usb::InterfaceInfoPtr>, - std::vector<device::UsbInterfaceDescriptor>> { - static mojo::Array<device::usb::InterfaceInfoPtr> Convert( - const std::vector<device::UsbInterfaceDescriptor>& interfaces); -}; - -template <> -struct TypeConverter<device::usb::ConfigurationInfoPtr, - device::UsbConfigDescriptor> { - static device::usb::ConfigurationInfoPtr Convert( - const device::UsbConfigDescriptor& config); -}; - -template <> -struct TypeConverter<device::usb::WebUsbFunctionSubsetPtr, - device::WebUsbFunctionSubset> { - static device::usb::WebUsbFunctionSubsetPtr Convert( - const device::WebUsbFunctionSubset& function); -}; - -template <> -struct TypeConverter<device::usb::WebUsbConfigurationSubsetPtr, - device::WebUsbConfigurationSubset> { - static device::usb::WebUsbConfigurationSubsetPtr Convert( - const device::WebUsbConfigurationSubset& config); -}; - -template <> -struct TypeConverter<device::usb::WebUsbDescriptorSetPtr, - device::WebUsbAllowedOrigins> { - static device::usb::WebUsbDescriptorSetPtr Convert( - const device::WebUsbAllowedOrigins& allowed_origins); -}; - -template <> -struct TypeConverter<device::usb::DeviceInfoPtr, device::UsbDevice> { - static device::usb::DeviceInfoPtr Convert(const device::UsbDevice& device); -}; - -template <> -struct TypeConverter<device::usb::IsochronousPacketPtr, - device::UsbDeviceHandle::IsochronousPacket> { - static device::usb::IsochronousPacketPtr Convert( - const device::UsbDeviceHandle::IsochronousPacket& packet); -}; - -} // namespace mojo - -#endif // DEVICE_DEVICES_APP_USB_TYPE_CONVERTERS_H_ |