1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
// 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_MOJO_TYPE_CONVERTERS_H_
#define DEVICE_USB_MOJO_TYPE_CONVERTERS_H_
#include <vector>
#include "device/usb/public/interfaces/device.mojom.h"
#include "device/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& iface);
};
// 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_
|
