OLD | NEW |
---|---|
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "extensions/browser/api/hid/hid_device_manager.h" | 5 #include "extensions/browser/api/hid/hid_device_manager.h" |
6 | 6 |
7 #include <limits> | 7 #include <limits> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "base/lazy_instance.h" | 10 #include "base/lazy_instance.h" |
11 #include "device/core/device_client.h" | 11 #include "device/core/device_client.h" |
12 #include "device/hid/hid_device_filter.h" | 12 #include "device/hid/hid_device_filter.h" |
13 #include "device/hid/hid_service.h" | 13 #include "device/hid/hid_service.h" |
14 #include "extensions/browser/api/device_permissions_manager.h" | |
14 #include "extensions/common/permissions/permissions_data.h" | 15 #include "extensions/common/permissions/permissions_data.h" |
15 #include "extensions/common/permissions/usb_device_permission.h" | 16 #include "extensions/common/permissions/usb_device_permission.h" |
16 | 17 |
17 namespace hid = extensions::core_api::hid; | 18 namespace hid = extensions::core_api::hid; |
18 | 19 |
19 using device::HidDeviceFilter; | 20 using device::HidDeviceFilter; |
20 using device::HidDeviceId; | 21 using device::HidDeviceId; |
21 using device::HidDeviceInfo; | 22 using device::HidDeviceInfo; |
22 using device::HidService; | 23 using device::HidService; |
23 | 24 |
(...skipping 26 matching lines...) Expand all Loading... | |
50 output->collections.push_back(make_linked_ptr(api_collection)); | 51 output->collections.push_back(make_linked_ptr(api_collection)); |
51 } | 52 } |
52 | 53 |
53 const std::vector<uint8>& report_descriptor = input->report_descriptor(); | 54 const std::vector<uint8>& report_descriptor = input->report_descriptor(); |
54 if (report_descriptor.size() > 0) { | 55 if (report_descriptor.size() > 0) { |
55 output->report_descriptor.assign(report_descriptor.begin(), | 56 output->report_descriptor.assign(report_descriptor.begin(), |
56 report_descriptor.end()); | 57 report_descriptor.end()); |
57 } | 58 } |
58 } | 59 } |
59 | 60 |
60 bool WillDispatchDeviceEvent(scoped_refptr<HidDeviceInfo> device_info, | 61 bool WillDispatchDeviceEvent(base::WeakPtr<HidDeviceManager> device_manager, |
62 scoped_refptr<device::HidDeviceInfo> device_info, | |
61 content::BrowserContext* context, | 63 content::BrowserContext* context, |
62 const Extension* extension, | 64 const Extension* extension, |
63 base::ListValue* event_args) { | 65 base::ListValue* event_args) { |
64 if (extension) { | 66 if (device_manager && extension) { |
65 return HidDeviceManager::HasPermission(extension, device_info); | 67 return device_manager->HasPermission(extension, device_info, false); |
66 } | 68 } |
67 return false; | 69 return false; |
68 } | 70 } |
69 | 71 |
70 } // namespace | 72 } // namespace |
71 | 73 |
72 struct HidDeviceManager::GetApiDevicesParams { | 74 struct HidDeviceManager::GetApiDevicesParams { |
73 public: | 75 public: |
74 GetApiDevicesParams(const Extension* extension, | 76 GetApiDevicesParams(const Extension* extension, |
75 const std::vector<HidDeviceFilter>& filters, | 77 const std::vector<HidDeviceFilter>& filters, |
76 const GetApiDevicesCallback& callback) | 78 const GetApiDevicesCallback& callback) |
77 : extension(extension), filters(filters), callback(callback) {} | 79 : extension(extension), filters(filters), callback(callback) {} |
78 ~GetApiDevicesParams() {} | 80 ~GetApiDevicesParams() {} |
79 | 81 |
80 const Extension* extension; | 82 const Extension* extension; |
81 std::vector<HidDeviceFilter> filters; | 83 std::vector<HidDeviceFilter> filters; |
82 GetApiDevicesCallback callback; | 84 GetApiDevicesCallback callback; |
83 }; | 85 }; |
84 | 86 |
85 HidDeviceManager::HidDeviceManager(content::BrowserContext* context) | 87 HidDeviceManager::HidDeviceManager(content::BrowserContext* context) |
86 : initialized_(false), | 88 : browser_context_(context), |
87 hid_service_observer_(this), | 89 hid_service_observer_(this), |
88 enumeration_ready_(false), | |
89 next_resource_id_(0), | |
90 weak_factory_(this) { | 90 weak_factory_(this) { |
91 event_router_ = EventRouter::Get(context); | 91 event_router_ = EventRouter::Get(context); |
92 if (event_router_) { | 92 if (event_router_) { |
93 event_router_->RegisterObserver(this, hid::OnDeviceAdded::kEventName); | 93 event_router_->RegisterObserver(this, hid::OnDeviceAdded::kEventName); |
94 event_router_->RegisterObserver(this, hid::OnDeviceRemoved::kEventName); | 94 event_router_->RegisterObserver(this, hid::OnDeviceRemoved::kEventName); |
95 } | 95 } |
96 } | 96 } |
97 | 97 |
98 HidDeviceManager::~HidDeviceManager() { | 98 HidDeviceManager::~HidDeviceManager() { |
99 DCHECK(thread_checker_.CalledOnValidThread()); | 99 DCHECK(thread_checker_.CalledOnValidThread()); |
(...skipping 18 matching lines...) Expand all Loading... | |
118 scoped_ptr<base::ListValue> devices = | 118 scoped_ptr<base::ListValue> devices = |
119 CreateApiDeviceList(extension, filters); | 119 CreateApiDeviceList(extension, filters); |
120 base::MessageLoop::current()->PostTask( | 120 base::MessageLoop::current()->PostTask( |
121 FROM_HERE, base::Bind(callback, base::Passed(&devices))); | 121 FROM_HERE, base::Bind(callback, base::Passed(&devices))); |
122 } else { | 122 } else { |
123 pending_enumerations_.push_back( | 123 pending_enumerations_.push_back( |
124 new GetApiDevicesParams(extension, filters, callback)); | 124 new GetApiDevicesParams(extension, filters, callback)); |
125 } | 125 } |
126 } | 126 } |
127 | 127 |
128 scoped_ptr<base::ListValue> HidDeviceManager::GetApiDevicesFromList( | |
129 const std::vector<scoped_refptr<HidDeviceInfo>>& devices) { | |
130 DCHECK(thread_checker_.CalledOnValidThread()); | |
131 scoped_ptr<base::ListValue> device_list(new base::ListValue()); | |
132 for (const auto& device : devices) { | |
133 const auto device_entry = resource_ids_.find(device->device_id()); | |
134 DCHECK(device_entry != resource_ids_.end()); | |
135 | |
136 hid::HidDeviceInfo device_info; | |
137 device_info.device_id = device_entry->second; | |
138 PopulateHidDeviceInfo(&device_info, device); | |
139 device_list->Append(device_info.ToValue().release()); | |
140 } | |
141 return device_list.Pass(); | |
142 } | |
143 | |
128 scoped_refptr<HidDeviceInfo> HidDeviceManager::GetDeviceInfo(int resource_id) { | 144 scoped_refptr<HidDeviceInfo> HidDeviceManager::GetDeviceInfo(int resource_id) { |
129 DCHECK(thread_checker_.CalledOnValidThread()); | 145 DCHECK(thread_checker_.CalledOnValidThread()); |
130 HidService* hid_service = device::DeviceClient::Get()->GetHidService(); | 146 HidService* hid_service = device::DeviceClient::Get()->GetHidService(); |
131 DCHECK(hid_service); | 147 DCHECK(hid_service); |
132 | 148 |
133 ResourceIdToDeviceIdMap::const_iterator device_iter = | 149 ResourceIdToDeviceIdMap::const_iterator device_iter = |
134 device_ids_.find(resource_id); | 150 device_ids_.find(resource_id); |
135 if (device_iter == device_ids_.end()) { | 151 if (device_iter == device_ids_.end()) { |
136 return nullptr; | 152 return nullptr; |
137 } | 153 } |
138 | 154 |
139 return hid_service->GetDeviceInfo(device_iter->second); | 155 return hid_service->GetDeviceInfo(device_iter->second); |
140 } | 156 } |
141 | 157 |
142 // static | |
143 bool HidDeviceManager::HasPermission(const Extension* extension, | 158 bool HidDeviceManager::HasPermission(const Extension* extension, |
144 scoped_refptr<HidDeviceInfo> device_info) { | 159 scoped_refptr<HidDeviceInfo> device_info, |
160 bool update_last_used) { | |
161 DevicePermissionsManager* permissions_manager = | |
162 DevicePermissionsManager::Get(browser_context_); | |
163 if (permissions_manager) { | |
Devlin
2015/05/06 23:04:28
Same question here - when do we expect this to be
| |
164 DevicePermissions* device_permissions = | |
165 permissions_manager->GetForExtension(extension->id()); | |
166 DCHECK(device_permissions); | |
167 | |
168 scoped_refptr<DevicePermissionEntry> permission_entry = | |
169 device_permissions->FindHidDeviceEntry(device_info); | |
170 if (permission_entry) { | |
171 if (update_last_used) { | |
172 permissions_manager->UpdateLastUsed(extension->id(), permission_entry); | |
173 } | |
174 return true; | |
175 } | |
176 } | |
177 | |
145 UsbDevicePermission::CheckParam usbParam( | 178 UsbDevicePermission::CheckParam usbParam( |
146 device_info->vendor_id(), device_info->product_id(), | 179 device_info->vendor_id(), device_info->product_id(), |
147 UsbDevicePermissionData::UNSPECIFIED_INTERFACE); | 180 UsbDevicePermissionData::UNSPECIFIED_INTERFACE); |
148 if (extension->permissions_data()->CheckAPIPermissionWithParam( | 181 if (extension->permissions_data()->CheckAPIPermissionWithParam( |
149 APIPermission::kUsbDevice, &usbParam)) { | 182 APIPermission::kUsbDevice, &usbParam)) { |
150 return true; | 183 return true; |
151 } | 184 } |
152 | 185 |
153 if (extension->permissions_data()->HasAPIPermission( | 186 if (extension->permissions_data()->HasAPIPermission( |
154 APIPermission::kU2fDevices)) { | 187 APIPermission::kU2fDevices)) { |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
243 hid_service->GetDeviceInfo(device_id); | 276 hid_service->GetDeviceInfo(device_id); |
244 if (!device_info) { | 277 if (!device_info) { |
245 continue; | 278 continue; |
246 } | 279 } |
247 | 280 |
248 if (!filters.empty() && | 281 if (!filters.empty() && |
249 !HidDeviceFilter::MatchesAny(device_info, filters)) { | 282 !HidDeviceFilter::MatchesAny(device_info, filters)) { |
250 continue; | 283 continue; |
251 } | 284 } |
252 | 285 |
253 if (!HasPermission(extension, device_info)) { | 286 if (!HasPermission(extension, device_info, false)) { |
254 continue; | 287 continue; |
255 } | 288 } |
256 | 289 |
257 hid::HidDeviceInfo api_device_info; | 290 hid::HidDeviceInfo api_device_info; |
258 api_device_info.device_id = resource_id; | 291 api_device_info.device_id = resource_id; |
259 PopulateHidDeviceInfo(&api_device_info, device_info); | 292 PopulateHidDeviceInfo(&api_device_info, device_info); |
260 | 293 |
261 // Expose devices with which user can communicate. | 294 // Expose devices with which user can communicate. |
262 if (api_device_info.collections.size() > 0) { | 295 if (api_device_info.collections.size() > 0) { |
263 api_devices->Append(api_device_info.ToValue().release()); | 296 api_devices->Append(api_device_info.ToValue().release()); |
(...skipping 17 matching lines...) Expand all Loading... | |
281 CreateApiDeviceList(params->extension, params->filters); | 314 CreateApiDeviceList(params->extension, params->filters); |
282 params->callback.Run(devices.Pass()); | 315 params->callback.Run(devices.Pass()); |
283 } | 316 } |
284 pending_enumerations_.clear(); | 317 pending_enumerations_.clear(); |
285 } | 318 } |
286 | 319 |
287 void HidDeviceManager::DispatchEvent(const std::string& event_name, | 320 void HidDeviceManager::DispatchEvent(const std::string& event_name, |
288 scoped_ptr<base::ListValue> event_args, | 321 scoped_ptr<base::ListValue> event_args, |
289 scoped_refptr<HidDeviceInfo> device_info) { | 322 scoped_refptr<HidDeviceInfo> device_info) { |
290 scoped_ptr<Event> event(new Event(event_name, event_args.Pass())); | 323 scoped_ptr<Event> event(new Event(event_name, event_args.Pass())); |
291 event->will_dispatch_callback = | 324 event->will_dispatch_callback = base::Bind( |
292 base::Bind(&WillDispatchDeviceEvent, device_info); | 325 &WillDispatchDeviceEvent, weak_factory_.GetWeakPtr(), device_info); |
293 event_router_->BroadcastEvent(event.Pass()); | 326 event_router_->BroadcastEvent(event.Pass()); |
294 } | 327 } |
295 | 328 |
296 } // namespace extensions | 329 } // namespace extensions |
OLD | NEW |