src/extensions/browser/api/hid/hid_device_manager.cc

   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
  25 HidDeviceManager::HidDeviceManager(content::BrowserContext* context)
  26     : next_resource_id_(0) {
  27 }
  28
  29 HidDeviceManager::~HidDeviceManager() {}
  30
  31 // static
  32 BrowserContextKeyedAPIFactory<HidDeviceManager>*
  33 HidDeviceManager::GetFactoryInstance() {
  34   static base::LazyInstance<BrowserContextKeyedAPIFactory<HidDeviceManager> >
  35       factory = LAZY_INSTANCE_INITIALIZER;
  36   return &factory.Get();
  37 }
  38
  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
 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
 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
 150 bool HidDeviceManager::IsCalledOnValidThread() {
 151   return content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE);
 152 }
 153
 154 void HidDeviceManager::UpdateDevices() {
 155   DCHECK(IsCalledOnValidThread());
 156   HidService* hid_service = device::DeviceClient::Get()->GetHidService();
 157   DCHECK(hid_service);
 158
 159   std::vector<device::HidDeviceInfo> devices;
 160   hid_service->GetDevices(&devices);
 161
 162   // Build an updated bidi mapping between resource ID and underlying device ID.
 163   DeviceIdToResourceIdMap new_resource_ids;
 164   ResourceIdToDeviceIdMap new_device_ids;
 165   for (std::vector<device::HidDeviceInfo>::const_iterator iter =
 166            devices.begin();
 167        iter != devices.end();
 168        ++iter) {
 169     const device::HidDeviceInfo& device_info = *iter;
 170     DeviceIdToResourceIdMap::iterator resource_iter =
 171         resource_ids_.find(device_info.device_id);
 172     int new_id;
 173     if (resource_iter != resource_ids_.end()) {
 174       new_id = resource_iter->second;
 175     } else {
 176       DCHECK_LT(next_resource_id_, std::numeric_limits<int>::max());
 177       new_id = next_resource_id_++;
 178     }
 179     new_resource_ids[device_info.device_id] = new_id;
 180     new_device_ids[new_id] = device_info.device_id;
 181   }
 182   device_ids_.swap(new_device_ids);
 183   resource_ids_.swap(new_resource_ids);
 184 }
 185
 186 }  // namespace extensions