1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "extensions/browser/api/hid/hid_device_manager.h"
6
7 #include <limits>
8 #include <vector>
9
10 #include "base/lazy_instance.h"
11 #include "content/public/browser/browser_thread.h"
12 #include "device/core/device_client.h"
13 #include "device/hid/hid_device_filter.h"
14 #include "device/hid/hid_service.h"
15 #include "extensions/browser/api/extensions_api_client.h"
16 #include "extensions/common/permissions/permissions_data.h"
17 #include "extensions/common/permissions/usb_device_permission.h"
18
19 using device::HidDeviceFilter;
20 using device::HidService;
21 using device::HidUsageAndPage;
22
23 namespace extensions {
24
HidDeviceManager(content::BrowserContext * context)25 HidDeviceManager::HidDeviceManager(content::BrowserContext* context)
26 : next_resource_id_(0) {
27 }
28
~HidDeviceManager()29 HidDeviceManager::~HidDeviceManager() {}
30
31 // static
32 BrowserContextKeyedAPIFactory<HidDeviceManager>*
GetFactoryInstance()33 HidDeviceManager::GetFactoryInstance() {
34 static base::LazyInstance<BrowserContextKeyedAPIFactory<HidDeviceManager> >
35 factory = LAZY_INSTANCE_INITIALIZER;
36 return &factory.Get();
37 }
38
GetApiDevices(const Extension * extension,const std::vector<HidDeviceFilter> & filters)39 scoped_ptr<base::ListValue> HidDeviceManager::GetApiDevices(
40 const Extension* extension,
41 const std::vector<HidDeviceFilter>& filters) {
42 DCHECK(IsCalledOnValidThread());
43 UpdateDevices();
44
45 HidService* hid_service = device::DeviceClient::Get()->GetHidService();
46 DCHECK(hid_service);
47 base::ListValue* api_devices = new base::ListValue();
48 for (ResourceIdToDeviceIdMap::const_iterator device_iter =
49 device_ids_.begin();
50 device_iter != device_ids_.end();
51 ++device_iter) {
52 int resource_id = device_iter->first;
53 device::HidDeviceId device_id = device_iter->second;
54 device::HidDeviceInfo device_info;
55
56 if (hid_service->GetDeviceInfo(device_id, &device_info)) {
57 if (!filters.empty() &&
58 !HidDeviceFilter::MatchesAny(device_info, filters)) {
59 continue;
60 }
61
62 if (!HasPermission(extension, device_info)) {
63 continue;
64 }
65
66 core_api::hid::HidDeviceInfo api_device_info;
67 api_device_info.device_id = resource_id;
68 api_device_info.vendor_id = device_info.vendor_id;
69 api_device_info.product_id = device_info.product_id;
70 api_device_info.max_input_report_size = device_info.max_input_report_size;
71 api_device_info.max_output_report_size =
72 device_info.max_output_report_size;
73 api_device_info.max_feature_report_size =
74 device_info.max_feature_report_size;
75
76 for (std::vector<device::HidCollectionInfo>::const_iterator
77 collections_iter = device_info.collections.begin();
78 collections_iter != device_info.collections.end();
79 ++collections_iter) {
80 const device::HidCollectionInfo& collection = *collections_iter;
81
82 // Don't expose sensitive data.
83 if (collection.usage.IsProtected()) {
84 continue;
85 }
86
87 core_api::hid::HidCollectionInfo* api_collection =
88 new core_api::hid::HidCollectionInfo();
89 api_collection->usage_page = collection.usage.usage_page;
90 api_collection->usage = collection.usage.usage;
91
92 api_collection->report_ids.resize(collection.report_ids.size());
93 std::copy(collection.report_ids.begin(),
94 collection.report_ids.end(),
95 api_collection->report_ids.begin());
96
97 api_device_info.collections.push_back(make_linked_ptr(api_collection));
98 }
99
100 // Expose devices with which user can communicate.
101 if (api_device_info.collections.size() > 0) {
102 api_devices->Append(api_device_info.ToValue().release());
103 }
104 }
105 }
106
107 return scoped_ptr<base::ListValue>(api_devices);
108 }
109
GetDeviceInfo(int resource_id,device::HidDeviceInfo * device_info)110 bool HidDeviceManager::GetDeviceInfo(int resource_id,
111 device::HidDeviceInfo* device_info) {
112 DCHECK(IsCalledOnValidThread());
113 UpdateDevices();
114 HidService* hid_service = device::DeviceClient::Get()->GetHidService();
115 DCHECK(hid_service);
116
117 ResourceIdToDeviceIdMap::const_iterator device_iter =
118 device_ids_.find(resource_id);
119 if (device_iter == device_ids_.end())
120 return false;
121
122 return hid_service->GetDeviceInfo(device_iter->second, device_info);
123 }
124
HasPermission(const Extension * extension,const device::HidDeviceInfo & device_info)125 bool HidDeviceManager::HasPermission(const Extension* extension,
126 const device::HidDeviceInfo& device_info) {
127 DCHECK(IsCalledOnValidThread());
128 UsbDevicePermission::CheckParam usbParam(
129 device_info.vendor_id,
130 device_info.product_id,
131 UsbDevicePermissionData::UNSPECIFIED_INTERFACE);
132 if (extension->permissions_data()->CheckAPIPermissionWithParam(
133 APIPermission::kUsbDevice, &usbParam)) {
134 return true;
135 }
136
137 if (extension->permissions_data()->HasAPIPermission(
138 APIPermission::kU2fDevices)) {
139 HidDeviceFilter u2f_filter;
140 u2f_filter.SetUsagePage(0xF1D0);
141 if (u2f_filter.Matches(device_info)) {
142 return true;
143 }
144 }
145
146 return false;
147 }
148
149 // static
IsCalledOnValidThread()150 bool HidDeviceManager::IsCalledOnValidThread() {
151 #if defined(OS_MACOSX)
152 // Migration from FILE thread to UI thread. OS X gets it first.
153 return content::BrowserThread::CurrentlyOn(content::BrowserThread::UI);
154 #else
155 // TODO(reillyg): Migrate Linux/CrOS and Windows as well.
156 return content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE);
157 #endif
158 }
159
UpdateDevices()160 void HidDeviceManager::UpdateDevices() {
161 DCHECK(IsCalledOnValidThread());
162 HidService* hid_service = device::DeviceClient::Get()->GetHidService();
163 DCHECK(hid_service);
164
165 std::vector<device::HidDeviceInfo> devices;
166 hid_service->GetDevices(&devices);
167
168 // Build an updated bidi mapping between resource ID and underlying device ID.
169 DeviceIdToResourceIdMap new_resource_ids;
170 ResourceIdToDeviceIdMap new_device_ids;
171 for (std::vector<device::HidDeviceInfo>::const_iterator iter =
172 devices.begin();
173 iter != devices.end();
174 ++iter) {
175 const device::HidDeviceInfo& device_info = *iter;
176 DeviceIdToResourceIdMap::iterator resource_iter =
177 resource_ids_.find(device_info.device_id);
178 int new_id;
179 if (resource_iter != resource_ids_.end()) {
180 new_id = resource_iter->second;
181 } else {
182 DCHECK_LT(next_resource_id_, std::numeric_limits<int>::max());
183 new_id = next_resource_id_++;
184 }
185 new_resource_ids[device_info.device_id] = new_id;
186 new_device_ids[new_id] = device_info.device_id;
187 }
188 device_ids_.swap(new_device_ids);
189 resource_ids_.swap(new_resource_ids);
190 }
191
192 } // namespace extensions
193