content/renderer/usb/type_converters.cc

   1 // Copyright 2015 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 "content/renderer/usb/type_converters.h"
   6
   7 #include "base/logging.h"
   8
   9 namespace mojo {
  10
  11 // static
  12 blink::WebUSBDevice::TransferDirection
  13 TypeConverter<blink::WebUSBDevice::TransferDirection,
  14               device::usb::TransferDirection>::
  15     Convert(const device::usb::TransferDirection& direction) {
  16   switch (direction) {
  17     case device::usb::TRANSFER_DIRECTION_IN:
  18       return blink::WebUSBDevice::TransferDirection::In;
  19     case device::usb::TRANSFER_DIRECTION_OUT:
  20       return blink::WebUSBDevice::TransferDirection::Out;
  21     default:
  22       NOTREACHED();
  23       return blink::WebUSBDevice::TransferDirection::In;
  24   }
  25 }
  26
  27 // static
  28 device::usb::TransferDirection
  29 TypeConverter<device::usb::TransferDirection,
  30               blink::WebUSBDevice::TransferDirection>::
  31     Convert(const blink::WebUSBDevice::TransferDirection& direction) {
  32   switch (direction) {
  33     case blink::WebUSBDevice::TransferDirection::In:
  34       return device::usb::TRANSFER_DIRECTION_IN;
  35     case blink::WebUSBDevice::TransferDirection::Out:
  36       return device::usb::TRANSFER_DIRECTION_OUT;
  37     default:
  38       NOTREACHED();
  39       return device::usb::TRANSFER_DIRECTION_IN;
  40   }
  41 }
  42
  43 // static
  44 device::usb::ControlTransferType
  45 TypeConverter<device::usb::ControlTransferType,
  46               blink::WebUSBDevice::RequestType>::
  47     Convert(const blink::WebUSBDevice::RequestType& direction) {
  48   switch (direction) {
  49     case blink::WebUSBDevice::RequestType::Standard:
  50       return device::usb::CONTROL_TRANSFER_TYPE_STANDARD;
  51     case blink::WebUSBDevice::RequestType::Class:
  52       return device::usb::CONTROL_TRANSFER_TYPE_CLASS;
  53     case blink::WebUSBDevice::RequestType::Vendor:
  54       return device::usb::CONTROL_TRANSFER_TYPE_VENDOR;
  55     default:
  56       NOTREACHED();
  57       return device::usb::CONTROL_TRANSFER_TYPE_STANDARD;
  58   }
  59 }
  60
  61 // static
  62 device::usb::ControlTransferRecipient
  63 TypeConverter<device::usb::ControlTransferRecipient,
  64               blink::WebUSBDevice::RequestRecipient>::
  65     Convert(const blink::WebUSBDevice::RequestRecipient& direction) {
  66   switch (direction) {
  67     case blink::WebUSBDevice::RequestRecipient::Device:
  68       return device::usb::CONTROL_TRANSFER_RECIPIENT_DEVICE;
  69     case blink::WebUSBDevice::RequestRecipient::Interface:
  70       return device::usb::CONTROL_TRANSFER_RECIPIENT_INTERFACE;
  71     case blink::WebUSBDevice::RequestRecipient::Endpoint:
  72       return device::usb::CONTROL_TRANSFER_RECIPIENT_ENDPOINT;
  73     case blink::WebUSBDevice::RequestRecipient::Other:
  74       return device::usb::CONTROL_TRANSFER_RECIPIENT_OTHER;
  75     default:
  76       NOTREACHED();
  77       return device::usb::CONTROL_TRANSFER_RECIPIENT_DEVICE;
  78   }
  79 }
  80
  81 // static
  82 device::usb::ControlTransferParamsPtr
  83 TypeConverter<device::usb::ControlTransferParamsPtr,
  84               blink::WebUSBDevice::ControlTransferParameters>::
  85     Convert(const blink::WebUSBDevice::ControlTransferParameters& parameters) {
  86   device::usb::ControlTransferParamsPtr params =
  87       device::usb::ControlTransferParams::New();
  88   params->type =
  89       mojo::ConvertTo<device::usb::ControlTransferType>(parameters.type);
  90   params->recipient = mojo::ConvertTo<device::usb::ControlTransferRecipient>(
  91       parameters.recipient);
  92   params->request = parameters.request;
  93   params->value = parameters.value;
  94   params->index = parameters.index;
  95   return params.Pass();
  96 }
  97
  98 // static
  99 blink::WebUSBDeviceInfo::Endpoint::Type TypeConverter<
 100     blink::WebUSBDeviceInfo::Endpoint::Type,
 101     device::usb::EndpointType>::Convert(const device::usb::EndpointType&
 102                                             endpoint_type) {
 103   switch (endpoint_type) {
 104     case device::usb::ENDPOINT_TYPE_BULK:
 105       return blink::WebUSBDeviceInfo::Endpoint::Type::Bulk;
 106     case device::usb::ENDPOINT_TYPE_INTERRUPT:
 107       return blink::WebUSBDeviceInfo::Endpoint::Type::Interrupt;
 108     case device::usb::ENDPOINT_TYPE_ISOCHRONOUS:
 109       return blink::WebUSBDeviceInfo::Endpoint::Type::Isochronous;
 110     default:
 111       NOTREACHED();
 112       return blink::WebUSBDeviceInfo::Endpoint::Type::Bulk;
 113   }
 114 }
 115
 116 // static
 117 blink::WebUSBDeviceInfo::Endpoint
 118 TypeConverter<blink::WebUSBDeviceInfo::Endpoint, device::usb::EndpointInfoPtr>::
 119     Convert(const device::usb::EndpointInfoPtr& info) {
 120   blink::WebUSBDeviceInfo::Endpoint endpoint;
 121   endpoint.endpointNumber = info->endpoint_number;
 122   endpoint.direction =
 123       mojo::ConvertTo<blink::WebUSBDevice::TransferDirection>(info->direction);
 124   endpoint.type =
 125       mojo::ConvertTo<blink::WebUSBDeviceInfo::Endpoint::Type>(info->type);
 126   endpoint.packetSize = info->packet_size;
 127   return endpoint;
 128 }
 129
 130 // static
 131 blink::WebUSBDeviceInfo::AlternateInterface
 132 TypeConverter<blink::WebUSBDeviceInfo::AlternateInterface,
 133               device::usb::AlternateInterfaceInfoPtr>::
 134     Convert(const device::usb::AlternateInterfaceInfoPtr& info) {
 135   blink::WebUSBDeviceInfo::AlternateInterface alternate;
 136   alternate.alternateSetting = info->alternate_setting;
 137   alternate.classCode = info->class_code;
 138   alternate.subclassCode = info->subclass_code;
 139   alternate.protocolCode = info->protocol_code;
 140   if (!info->interface_name.is_null())
 141     alternate.interfaceName = blink::WebString::fromUTF8(info->interface_name);
 142   alternate.endpoints = blink::WebVector<blink::WebUSBDeviceInfo::Endpoint>(
 143       info->endpoints.size());
 144   for (size_t i = 0; i < info->endpoints.size(); ++i) {
 145     alternate.endpoints[i] =
 146         mojo::ConvertTo<blink::WebUSBDeviceInfo::Endpoint>(info->endpoints[i]);
 147   }
 148   return alternate;
 149 }
 150
 151 // static
 152 blink::WebUSBDeviceInfo::Interface TypeConverter<
 153     blink::WebUSBDeviceInfo::Interface,
 154     device::usb::InterfaceInfoPtr>::Convert(const device::usb::InterfaceInfoPtr&
 155                                                 info) {
 156   blink::WebUSBDeviceInfo::Interface interface;
 157   interface.interfaceNumber = info->interface_number;
 158   interface.alternates =
 159       blink::WebVector<blink::WebUSBDeviceInfo::AlternateInterface>(
 160           info->alternates.size());
 161   for (size_t i = 0; i < info->alternates.size(); ++i) {
 162     interface.alternates[i] =
 163         mojo::ConvertTo<blink::WebUSBDeviceInfo::AlternateInterface>(
 164             info->alternates[i]);
 165   }
 166   return interface;
 167 }
 168
 169 // static
 170 blink::WebUSBDeviceInfo::Configuration
 171 TypeConverter<blink::WebUSBDeviceInfo::Configuration,
 172               device::usb::ConfigurationInfoPtr>::
 173     Convert(const device::usb::ConfigurationInfoPtr& info) {
 174   blink::WebUSBDeviceInfo::Configuration config;
 175   config.configurationValue = info->configuration_value;
 176   if (!info->configuration_name.is_null()) {
 177     config.configurationName =
 178         blink::WebString::fromUTF8(info->configuration_name);
 179   }
 180   config.interfaces = blink::WebVector<blink::WebUSBDeviceInfo::Interface>(
 181       info->interfaces.size());
 182   for (size_t i = 0; i < info->interfaces.size(); ++i) {
 183     config.interfaces[i] = mojo::ConvertTo<blink::WebUSBDeviceInfo::Interface>(
 184         info->interfaces[i]);
 185   }
 186   return config;
 187 }
 188
 189 // static
 190 blink::WebUSBDeviceInfo
 191 TypeConverter<blink::WebUSBDeviceInfo, device::usb::DeviceInfoPtr>::Convert(
 192     const device::usb::DeviceInfoPtr& info) {
 193   blink::WebUSBDeviceInfo device;
 194   device.guid = blink::WebString::fromUTF8(info->guid);
 195   device.usbVersionMajor = info->usb_version_major;
 196   device.usbVersionMinor = info->usb_version_minor;
 197   device.usbVersionSubminor = info->usb_version_subminor;
 198   device.deviceClass = info->class_code;
 199   device.deviceSubclass = info->subclass_code;
 200   device.deviceProtocol = info->protocol_code;
 201   device.vendorID = info->vendor_id;
 202   device.productID = info->product_id;
 203   device.deviceVersionMajor = info->device_version_major;
 204   device.deviceVersionMinor = info->device_version_minor;
 205   device.deviceVersionSubminor = info->device_version_subminor;
 206   if (!info->manufacturer_name.is_null()) {
 207     device.manufacturerName =
 208         blink::WebString::fromUTF8(info->manufacturer_name);
 209   }
 210   if (!info->product_name.is_null())
 211     device.productName = blink::WebString::fromUTF8(info->product_name);
 212   if (!info->serial_number.is_null())
 213     device.serialNumber = blink::WebString::fromUTF8(info->serial_number);
 214   device.configurations =
 215       blink::WebVector<blink::WebUSBDeviceInfo::Configuration>(
 216           info->configurations.size());
 217   for (size_t i = 0; i < info->configurations.size(); ++i) {
 218     device.configurations[i] =
 219         mojo::ConvertTo<blink::WebUSBDeviceInfo::Configuration>(
 220             info->configurations[i]);
 221   }
 222   return device;
 223 }
 224
 225 // static
 226 device::usb::DeviceFilterPtr
 227 TypeConverter<device::usb::DeviceFilterPtr, blink::WebUSBDeviceFilter>::Convert(
 228     const blink::WebUSBDeviceFilter& web_filter) {
 229   device::usb::DeviceFilterPtr filter = device::usb::DeviceFilter::New();
 230   filter->has_vendor_id = web_filter.hasVendorID;
 231   filter->vendor_id = web_filter.vendorID;
 232   filter->has_product_id = web_filter.hasProductID;
 233   filter->product_id = web_filter.productID;
 234   filter->has_class_code = web_filter.hasClassCode;
 235   filter->class_code = web_filter.classCode;
 236   filter->has_subclass_code = web_filter.hasSubclassCode;
 237   filter->subclass_code = web_filter.subclassCode;
 238   filter->has_protocol_code = web_filter.hasProtocolCode;
 239   filter->protocol_code = web_filter.protocolCode;
 240   return filter.Pass();
 241 }
 242
 243 // static
 244 device::usb::EnumerationOptionsPtr
 245 TypeConverter<device::usb::EnumerationOptionsPtr,
 246               blink::WebUSBDeviceRequestOptions>::
 247     Convert(const blink::WebUSBDeviceRequestOptions& web_options) {
 248   device::usb::EnumerationOptionsPtr options =
 249       device::usb::EnumerationOptions::New();
 250   options->filters = mojo::Array<device::usb::DeviceFilterPtr>::New(
 251       web_options.filters.size());
 252   for (size_t i = 0; i < web_options.filters.size(); ++i) {
 253     options->filters[i] =
 254         device::usb::DeviceFilter::From(web_options.filters[i]);
 255   }
 256   return options.Pass();
 257 }
 258
 259 }  // namespace mojo