blob: 40bfd1ec345a5803117be0b2fae701cdc42cf130 (
plain)
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
135
136
137
138
|
// 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.
#ifndef DEVICE_USB_USB_DEVICE_IMPL_H_
#define DEVICE_USB_USB_DEVICE_IMPL_H_
#include <stdint.h>
#include <string>
#include <utility>
#include <vector>
#include "base/callback.h"
#include "base/macros.h"
#include "base/threading/thread_checker.h"
#include "build/build_config.h"
#include "device/usb/usb_descriptors.h"
#include "device/usb/usb_device.h"
#include "device/usb/webusb_descriptors.h"
struct libusb_device;
struct libusb_config_descriptor;
struct libusb_device_handle;
namespace base {
class SequencedTaskRunner;
}
namespace dbus {
class FileDescriptor;
}
namespace device {
class UsbDeviceHandleImpl;
class UsbContext;
typedef struct libusb_device* PlatformUsbDevice;
typedef struct libusb_config_descriptor* PlatformUsbConfigDescriptor;
typedef struct libusb_device_handle* PlatformUsbDeviceHandle;
class UsbDeviceImpl : public UsbDevice {
public:
// UsbDevice implementation:
#if defined(OS_CHROMEOS)
void CheckUsbAccess(const ResultCallback& callback) override;
#endif // OS_CHROMEOS
void Open(const OpenCallback& callback) override;
const UsbConfigDescriptor* GetActiveConfiguration() override;
// These functions are used during enumeration only. The values must not
// change during the object's lifetime.
void set_manufacturer_string(const base::string16& value) {
manufacturer_string_ = value;
}
void set_product_string(const base::string16& value) {
product_string_ = value;
}
void set_serial_number(const base::string16& value) {
serial_number_ = value;
}
void set_device_path(const std::string& value) { device_path_ = value; }
void set_webusb_allowed_origins(
scoped_ptr<WebUsbAllowedOrigins> allowed_origins) {
webusb_allowed_origins_ = std::move(allowed_origins);
}
void set_webusb_landing_page(const GURL& url) { webusb_landing_page_ = url; }
PlatformUsbDevice platform_device() const { return platform_device_; }
protected:
friend class UsbServiceImpl;
friend class UsbDeviceHandleImpl;
// Called by UsbServiceImpl only;
UsbDeviceImpl(scoped_refptr<UsbContext> context,
PlatformUsbDevice platform_device,
uint16_t vendor_id,
uint16_t product_id,
scoped_refptr<base::SequencedTaskRunner> blocking_task_runner);
~UsbDeviceImpl() override;
// Called only by UsbServiceImpl.
void set_visited(bool visited) { visited_ = visited; }
bool was_visited() const { return visited_; }
void OnDisconnect();
void ReadAllConfigurations();
// Called by UsbDeviceHandleImpl.
void Close(scoped_refptr<UsbDeviceHandle> handle);
void RefreshActiveConfiguration();
private:
void GetAllConfigurations();
#if defined(OS_CHROMEOS)
void OnOpenRequestComplete(const OpenCallback& callback,
dbus::FileDescriptor fd);
void OnOpenRequestError(const OpenCallback& callback,
const std::string& error_name,
const std::string& error_message);
void OpenOnBlockingThreadWithFd(dbus::FileDescriptor fd,
const OpenCallback& callback);
#endif
void OpenOnBlockingThread(const OpenCallback& callback);
void Opened(PlatformUsbDeviceHandle platform_handle,
const OpenCallback& callback);
base::ThreadChecker thread_checker_;
PlatformUsbDevice platform_device_;
bool visited_ = false;
// On Chrome OS device path is necessary to request access from the permission
// broker.
std::string device_path_;
// The current device configuration descriptor. May be null if the device is
// in an unconfigured state; if not null, it is a pointer to one of the
// items at UsbDevice::configurations_.
const UsbConfigDescriptor* active_configuration_ = nullptr;
// Retain the context so that it will not be released before UsbDevice.
scoped_refptr<UsbContext> context_;
// Opened handles.
typedef std::vector<scoped_refptr<UsbDeviceHandleImpl> > HandlesVector;
HandlesVector handles_;
scoped_refptr<base::SequencedTaskRunner> task_runner_;
scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
DISALLOW_COPY_AND_ASSIGN(UsbDeviceImpl);
};
} // namespace device
#endif // DEVICE_USB_USB_DEVICE_IMPL_H_
|
