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
|
// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "third_party/blink/renderer/modules/webusb/usb_interface.h"
#include "base/notreached.h"
#include "services/device/public/mojom/usb_device.mojom-blink.h"
#include "third_party/blink/renderer/modules/webusb/usb_alternate_interface.h"
#include "third_party/blink/renderer/modules/webusb/usb_configuration.h"
#include "third_party/blink/renderer/modules/webusb/usb_device.h"
#include "third_party/blink/renderer/platform/bindings/exception_state.h"
namespace blink {
USBInterface* USBInterface::Create(const USBConfiguration* configuration,
wtf_size_t interface_index) {
return MakeGarbageCollected<USBInterface>(
configuration->Device(), configuration->Index(), interface_index);
}
USBInterface* USBInterface::Create(const USBConfiguration* configuration,
uint8_t interface_number,
ExceptionState& exception_state) {
const auto& interfaces = configuration->Info().interfaces;
for (wtf_size_t i = 0; i < interfaces.size(); ++i) {
if (interfaces[i]->interface_number == interface_number) {
return MakeGarbageCollected<USBInterface>(configuration->Device(),
configuration->Index(), i);
}
}
exception_state.ThrowRangeError("Invalid interface index.");
return nullptr;
}
USBInterface::USBInterface(const USBDevice* device,
wtf_size_t configuration_index,
wtf_size_t interface_index)
: device_(device),
configuration_index_(configuration_index),
interface_index_(interface_index) {
DCHECK_LT(configuration_index_, device_->Info().configurations.size());
DCHECK_LT(
interface_index_,
device_->Info().configurations[configuration_index_]->interfaces.size());
for (wtf_size_t i = 0; i < Info().alternates.size(); ++i)
alternates_.push_back(USBAlternateInterface::Create(this, i));
}
const device::mojom::blink::UsbInterfaceInfo& USBInterface::Info() const {
return *device_->Info()
.configurations[configuration_index_]
->interfaces[interface_index_];
}
USBAlternateInterface* USBInterface::alternate() const {
wtf_size_t index = 0;
if (device_->IsInterfaceClaimed(configuration_index_, interface_index_)) {
index = device_->SelectedAlternateInterfaceIndex(interface_index_);
}
// Every interface is guaranteed to have at least one alternate according
// according to Interface Descriptor in section 9.6.5 of USB31 specification,
// and how UsbInterfaceInfo is constructed by BuildUsbInterfaceInfoPtr() and
// AggregateInterfacesForConfig() in services/device/usb/usb_descriptors.cc.
DCHECK_LT(index, alternates_.size());
return alternates_[index].Get();
}
HeapVector<Member<USBAlternateInterface>> USBInterface::alternates() const {
return alternates_;
}
bool USBInterface::claimed() const {
return device_->IsInterfaceClaimed(configuration_index_, interface_index_);
}
void USBInterface::Trace(Visitor* visitor) const {
visitor->Trace(device_);
visitor->Trace(alternates_);
ScriptWrappable::Trace(visitor);
}
} // namespace blink
|
