1059 lines
26 KiB
C++
Executable File
1059 lines
26 KiB
C++
Executable File
// Copyright (c) 2019 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.
|
|
|
|
// GENERATED FROM THE API DEFINITION IN
|
|
// extensions/common/api/hid.idl
|
|
// DO NOT EDIT.
|
|
|
|
#include "tools/json_schema_compiler/util.h"
|
|
#include "base/logging.h"
|
|
#include "base/strings/string_number_conversions.h"
|
|
#include "base/strings/utf_string_conversions.h"
|
|
#include "base/values.h"
|
|
#include "extensions/common/api/hid.h"
|
|
#include <set>
|
|
#include <utility>
|
|
|
|
using base::UTF8ToUTF16;
|
|
|
|
namespace extensions {
|
|
namespace api {
|
|
namespace hid {
|
|
//
|
|
// Types
|
|
//
|
|
|
|
HidCollectionInfo::HidCollectionInfo()
|
|
: usage_page(0),
|
|
usage(0) {}
|
|
|
|
HidCollectionInfo::~HidCollectionInfo() {}
|
|
HidCollectionInfo::HidCollectionInfo(HidCollectionInfo&& rhs)
|
|
: usage_page(rhs.usage_page),
|
|
usage(rhs.usage),
|
|
report_ids(std::move(rhs.report_ids)){
|
|
}
|
|
|
|
HidCollectionInfo& HidCollectionInfo::operator=(HidCollectionInfo&& rhs)
|
|
{
|
|
usage_page = rhs.usage_page;
|
|
usage = rhs.usage;
|
|
report_ids = std::move(rhs.report_ids);
|
|
return *this;
|
|
}
|
|
|
|
// static
|
|
bool HidCollectionInfo::Populate(
|
|
const base::Value& value, HidCollectionInfo* out) {
|
|
if (!value.is_dict()) {
|
|
return false;
|
|
}
|
|
const base::DictionaryValue* dict = static_cast<const base::DictionaryValue*>(&value);
|
|
const base::Value* usage_page_value = NULL;
|
|
if (!dict->GetWithoutPathExpansion("usagePage", &usage_page_value)) {
|
|
return false;
|
|
}
|
|
{
|
|
if (!usage_page_value->GetAsInteger(&out->usage_page)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
const base::Value* usage_value = NULL;
|
|
if (!dict->GetWithoutPathExpansion("usage", &usage_value)) {
|
|
return false;
|
|
}
|
|
{
|
|
if (!usage_value->GetAsInteger(&out->usage)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
const base::Value* report_ids_value = NULL;
|
|
if (!dict->GetWithoutPathExpansion("reportIds", &report_ids_value)) {
|
|
return false;
|
|
}
|
|
{
|
|
const base::ListValue* list = NULL;
|
|
if (!report_ids_value->GetAsList(&list)) {
|
|
return false;
|
|
}
|
|
else {
|
|
if (!json_schema_compiler::util::PopulateArrayFromList(*list, &out->report_ids)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// static
|
|
std::unique_ptr<HidCollectionInfo> HidCollectionInfo::FromValue(const base::Value& value) {
|
|
std::unique_ptr<HidCollectionInfo> out(new HidCollectionInfo());
|
|
if (!Populate(value, out.get()))
|
|
return nullptr;
|
|
return out;
|
|
}
|
|
|
|
std::unique_ptr<base::DictionaryValue> HidCollectionInfo::ToValue() const {
|
|
std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
|
|
|
|
value->SetWithoutPathExpansion("usagePage", std::make_unique<base::Value>(this->usage_page));
|
|
|
|
value->SetWithoutPathExpansion("usage", std::make_unique<base::Value>(this->usage));
|
|
|
|
value->SetWithoutPathExpansion("reportIds", json_schema_compiler::util::CreateValueFromArray(this->report_ids));
|
|
|
|
|
|
return value;
|
|
}
|
|
|
|
|
|
HidDeviceInfo::HidDeviceInfo()
|
|
: device_id(0),
|
|
vendor_id(0),
|
|
product_id(0),
|
|
max_input_report_size(0),
|
|
max_output_report_size(0),
|
|
max_feature_report_size(0) {}
|
|
|
|
HidDeviceInfo::~HidDeviceInfo() {}
|
|
HidDeviceInfo::HidDeviceInfo(HidDeviceInfo&& rhs)
|
|
: device_id(rhs.device_id),
|
|
vendor_id(rhs.vendor_id),
|
|
product_id(rhs.product_id),
|
|
product_name(std::move(rhs.product_name)),
|
|
serial_number(std::move(rhs.serial_number)),
|
|
collections(std::move(rhs.collections)),
|
|
max_input_report_size(rhs.max_input_report_size),
|
|
max_output_report_size(rhs.max_output_report_size),
|
|
max_feature_report_size(rhs.max_feature_report_size),
|
|
report_descriptor(std::move(rhs.report_descriptor)){
|
|
}
|
|
|
|
HidDeviceInfo& HidDeviceInfo::operator=(HidDeviceInfo&& rhs)
|
|
{
|
|
device_id = rhs.device_id;
|
|
vendor_id = rhs.vendor_id;
|
|
product_id = rhs.product_id;
|
|
product_name = std::move(rhs.product_name);
|
|
serial_number = std::move(rhs.serial_number);
|
|
collections = std::move(rhs.collections);
|
|
max_input_report_size = rhs.max_input_report_size;
|
|
max_output_report_size = rhs.max_output_report_size;
|
|
max_feature_report_size = rhs.max_feature_report_size;
|
|
report_descriptor = std::move(rhs.report_descriptor);
|
|
return *this;
|
|
}
|
|
|
|
// static
|
|
bool HidDeviceInfo::Populate(
|
|
const base::Value& value, HidDeviceInfo* out) {
|
|
if (!value.is_dict()) {
|
|
return false;
|
|
}
|
|
const base::DictionaryValue* dict = static_cast<const base::DictionaryValue*>(&value);
|
|
const base::Value* device_id_value = NULL;
|
|
if (!dict->GetWithoutPathExpansion("deviceId", &device_id_value)) {
|
|
return false;
|
|
}
|
|
{
|
|
if (!device_id_value->GetAsInteger(&out->device_id)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
const base::Value* vendor_id_value = NULL;
|
|
if (!dict->GetWithoutPathExpansion("vendorId", &vendor_id_value)) {
|
|
return false;
|
|
}
|
|
{
|
|
if (!vendor_id_value->GetAsInteger(&out->vendor_id)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
const base::Value* product_id_value = NULL;
|
|
if (!dict->GetWithoutPathExpansion("productId", &product_id_value)) {
|
|
return false;
|
|
}
|
|
{
|
|
if (!product_id_value->GetAsInteger(&out->product_id)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
const base::Value* product_name_value = NULL;
|
|
if (!dict->GetWithoutPathExpansion("productName", &product_name_value)) {
|
|
return false;
|
|
}
|
|
{
|
|
if (!product_name_value->GetAsString(&out->product_name)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
const base::Value* serial_number_value = NULL;
|
|
if (!dict->GetWithoutPathExpansion("serialNumber", &serial_number_value)) {
|
|
return false;
|
|
}
|
|
{
|
|
if (!serial_number_value->GetAsString(&out->serial_number)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
const base::Value* collections_value = NULL;
|
|
if (!dict->GetWithoutPathExpansion("collections", &collections_value)) {
|
|
return false;
|
|
}
|
|
{
|
|
const base::ListValue* list = NULL;
|
|
if (!collections_value->GetAsList(&list)) {
|
|
return false;
|
|
}
|
|
else {
|
|
if (!json_schema_compiler::util::PopulateArrayFromList(*list, &out->collections)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
const base::Value* max_input_report_size_value = NULL;
|
|
if (!dict->GetWithoutPathExpansion("maxInputReportSize", &max_input_report_size_value)) {
|
|
return false;
|
|
}
|
|
{
|
|
if (!max_input_report_size_value->GetAsInteger(&out->max_input_report_size)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
const base::Value* max_output_report_size_value = NULL;
|
|
if (!dict->GetWithoutPathExpansion("maxOutputReportSize", &max_output_report_size_value)) {
|
|
return false;
|
|
}
|
|
{
|
|
if (!max_output_report_size_value->GetAsInteger(&out->max_output_report_size)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
const base::Value* max_feature_report_size_value = NULL;
|
|
if (!dict->GetWithoutPathExpansion("maxFeatureReportSize", &max_feature_report_size_value)) {
|
|
return false;
|
|
}
|
|
{
|
|
if (!max_feature_report_size_value->GetAsInteger(&out->max_feature_report_size)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
const base::Value* report_descriptor_value = NULL;
|
|
if (!dict->GetWithoutPathExpansion("reportDescriptor", &report_descriptor_value)) {
|
|
return false;
|
|
}
|
|
{
|
|
if (!report_descriptor_value->is_blob()) {
|
|
return false;
|
|
}
|
|
else {
|
|
out->report_descriptor = report_descriptor_value->GetBlob();
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// static
|
|
std::unique_ptr<HidDeviceInfo> HidDeviceInfo::FromValue(const base::Value& value) {
|
|
std::unique_ptr<HidDeviceInfo> out(new HidDeviceInfo());
|
|
if (!Populate(value, out.get()))
|
|
return nullptr;
|
|
return out;
|
|
}
|
|
|
|
std::unique_ptr<base::DictionaryValue> HidDeviceInfo::ToValue() const {
|
|
std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
|
|
|
|
value->SetWithoutPathExpansion("deviceId", std::make_unique<base::Value>(this->device_id));
|
|
|
|
value->SetWithoutPathExpansion("vendorId", std::make_unique<base::Value>(this->vendor_id));
|
|
|
|
value->SetWithoutPathExpansion("productId", std::make_unique<base::Value>(this->product_id));
|
|
|
|
value->SetWithoutPathExpansion("productName", std::make_unique<base::Value>(this->product_name));
|
|
|
|
value->SetWithoutPathExpansion("serialNumber", std::make_unique<base::Value>(this->serial_number));
|
|
|
|
value->SetWithoutPathExpansion("collections", json_schema_compiler::util::CreateValueFromArray(this->collections));
|
|
|
|
value->SetWithoutPathExpansion("maxInputReportSize", std::make_unique<base::Value>(this->max_input_report_size));
|
|
|
|
value->SetWithoutPathExpansion("maxOutputReportSize", std::make_unique<base::Value>(this->max_output_report_size));
|
|
|
|
value->SetWithoutPathExpansion("maxFeatureReportSize", std::make_unique<base::Value>(this->max_feature_report_size));
|
|
|
|
value->SetWithoutPathExpansion("reportDescriptor", std::make_unique<base::Value>(this->report_descriptor));
|
|
|
|
|
|
return value;
|
|
}
|
|
|
|
|
|
HidConnectInfo::HidConnectInfo()
|
|
: connection_id(0) {}
|
|
|
|
HidConnectInfo::~HidConnectInfo() {}
|
|
HidConnectInfo::HidConnectInfo(HidConnectInfo&& rhs)
|
|
: connection_id(rhs.connection_id){
|
|
}
|
|
|
|
HidConnectInfo& HidConnectInfo::operator=(HidConnectInfo&& rhs)
|
|
{
|
|
connection_id = rhs.connection_id;
|
|
return *this;
|
|
}
|
|
|
|
// static
|
|
bool HidConnectInfo::Populate(
|
|
const base::Value& value, HidConnectInfo* out) {
|
|
if (!value.is_dict()) {
|
|
return false;
|
|
}
|
|
const base::DictionaryValue* dict = static_cast<const base::DictionaryValue*>(&value);
|
|
const base::Value* connection_id_value = NULL;
|
|
if (!dict->GetWithoutPathExpansion("connectionId", &connection_id_value)) {
|
|
return false;
|
|
}
|
|
{
|
|
if (!connection_id_value->GetAsInteger(&out->connection_id)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// static
|
|
std::unique_ptr<HidConnectInfo> HidConnectInfo::FromValue(const base::Value& value) {
|
|
std::unique_ptr<HidConnectInfo> out(new HidConnectInfo());
|
|
if (!Populate(value, out.get()))
|
|
return nullptr;
|
|
return out;
|
|
}
|
|
|
|
std::unique_ptr<base::DictionaryValue> HidConnectInfo::ToValue() const {
|
|
std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
|
|
|
|
value->SetWithoutPathExpansion("connectionId", std::make_unique<base::Value>(this->connection_id));
|
|
|
|
|
|
return value;
|
|
}
|
|
|
|
|
|
DeviceFilter::DeviceFilter()
|
|
{}
|
|
|
|
DeviceFilter::~DeviceFilter() {}
|
|
DeviceFilter::DeviceFilter(DeviceFilter&& rhs)
|
|
: vendor_id(std::move(rhs.vendor_id)),
|
|
product_id(std::move(rhs.product_id)),
|
|
usage_page(std::move(rhs.usage_page)),
|
|
usage(std::move(rhs.usage)){
|
|
}
|
|
|
|
DeviceFilter& DeviceFilter::operator=(DeviceFilter&& rhs)
|
|
{
|
|
vendor_id = std::move(rhs.vendor_id);
|
|
product_id = std::move(rhs.product_id);
|
|
usage_page = std::move(rhs.usage_page);
|
|
usage = std::move(rhs.usage);
|
|
return *this;
|
|
}
|
|
|
|
// static
|
|
bool DeviceFilter::Populate(
|
|
const base::Value& value, DeviceFilter* out) {
|
|
if (!value.is_dict()) {
|
|
return false;
|
|
}
|
|
const base::DictionaryValue* dict = static_cast<const base::DictionaryValue*>(&value);
|
|
const base::Value* vendor_id_value = NULL;
|
|
if (dict->GetWithoutPathExpansion("vendorId", &vendor_id_value)) {
|
|
{
|
|
int temp;
|
|
if (!vendor_id_value->GetAsInteger(&temp)) {
|
|
out->vendor_id.reset();
|
|
return false;
|
|
}
|
|
else
|
|
out->vendor_id.reset(new int(temp));
|
|
}
|
|
}
|
|
|
|
const base::Value* product_id_value = NULL;
|
|
if (dict->GetWithoutPathExpansion("productId", &product_id_value)) {
|
|
{
|
|
int temp;
|
|
if (!product_id_value->GetAsInteger(&temp)) {
|
|
out->product_id.reset();
|
|
return false;
|
|
}
|
|
else
|
|
out->product_id.reset(new int(temp));
|
|
}
|
|
}
|
|
|
|
const base::Value* usage_page_value = NULL;
|
|
if (dict->GetWithoutPathExpansion("usagePage", &usage_page_value)) {
|
|
{
|
|
int temp;
|
|
if (!usage_page_value->GetAsInteger(&temp)) {
|
|
out->usage_page.reset();
|
|
return false;
|
|
}
|
|
else
|
|
out->usage_page.reset(new int(temp));
|
|
}
|
|
}
|
|
|
|
const base::Value* usage_value = NULL;
|
|
if (dict->GetWithoutPathExpansion("usage", &usage_value)) {
|
|
{
|
|
int temp;
|
|
if (!usage_value->GetAsInteger(&temp)) {
|
|
out->usage.reset();
|
|
return false;
|
|
}
|
|
else
|
|
out->usage.reset(new int(temp));
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// static
|
|
std::unique_ptr<DeviceFilter> DeviceFilter::FromValue(const base::Value& value) {
|
|
std::unique_ptr<DeviceFilter> out(new DeviceFilter());
|
|
if (!Populate(value, out.get()))
|
|
return nullptr;
|
|
return out;
|
|
}
|
|
|
|
std::unique_ptr<base::DictionaryValue> DeviceFilter::ToValue() const {
|
|
std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
|
|
|
|
if (this->vendor_id.get()) {
|
|
value->SetWithoutPathExpansion("vendorId", std::make_unique<base::Value>(*this->vendor_id));
|
|
|
|
}
|
|
if (this->product_id.get()) {
|
|
value->SetWithoutPathExpansion("productId", std::make_unique<base::Value>(*this->product_id));
|
|
|
|
}
|
|
if (this->usage_page.get()) {
|
|
value->SetWithoutPathExpansion("usagePage", std::make_unique<base::Value>(*this->usage_page));
|
|
|
|
}
|
|
if (this->usage.get()) {
|
|
value->SetWithoutPathExpansion("usage", std::make_unique<base::Value>(*this->usage));
|
|
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
|
|
GetDevicesOptions::GetDevicesOptions()
|
|
{}
|
|
|
|
GetDevicesOptions::~GetDevicesOptions() {}
|
|
GetDevicesOptions::GetDevicesOptions(GetDevicesOptions&& rhs)
|
|
: vendor_id(std::move(rhs.vendor_id)),
|
|
product_id(std::move(rhs.product_id)),
|
|
filters(std::move(rhs.filters)){
|
|
}
|
|
|
|
GetDevicesOptions& GetDevicesOptions::operator=(GetDevicesOptions&& rhs)
|
|
{
|
|
vendor_id = std::move(rhs.vendor_id);
|
|
product_id = std::move(rhs.product_id);
|
|
filters = std::move(rhs.filters);
|
|
return *this;
|
|
}
|
|
|
|
// static
|
|
bool GetDevicesOptions::Populate(
|
|
const base::Value& value, GetDevicesOptions* out) {
|
|
if (!value.is_dict()) {
|
|
return false;
|
|
}
|
|
const base::DictionaryValue* dict = static_cast<const base::DictionaryValue*>(&value);
|
|
const base::Value* vendor_id_value = NULL;
|
|
if (dict->GetWithoutPathExpansion("vendorId", &vendor_id_value)) {
|
|
{
|
|
int temp;
|
|
if (!vendor_id_value->GetAsInteger(&temp)) {
|
|
out->vendor_id.reset();
|
|
return false;
|
|
}
|
|
else
|
|
out->vendor_id.reset(new int(temp));
|
|
}
|
|
}
|
|
|
|
const base::Value* product_id_value = NULL;
|
|
if (dict->GetWithoutPathExpansion("productId", &product_id_value)) {
|
|
{
|
|
int temp;
|
|
if (!product_id_value->GetAsInteger(&temp)) {
|
|
out->product_id.reset();
|
|
return false;
|
|
}
|
|
else
|
|
out->product_id.reset(new int(temp));
|
|
}
|
|
}
|
|
|
|
const base::Value* filters_value = NULL;
|
|
if (dict->GetWithoutPathExpansion("filters", &filters_value)) {
|
|
{
|
|
const base::ListValue* list = NULL;
|
|
if (!filters_value->GetAsList(&list)) {
|
|
return false;
|
|
}
|
|
else {
|
|
if (!json_schema_compiler::util::PopulateOptionalArrayFromList(*list, &out->filters)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// static
|
|
std::unique_ptr<GetDevicesOptions> GetDevicesOptions::FromValue(const base::Value& value) {
|
|
std::unique_ptr<GetDevicesOptions> out(new GetDevicesOptions());
|
|
if (!Populate(value, out.get()))
|
|
return nullptr;
|
|
return out;
|
|
}
|
|
|
|
std::unique_ptr<base::DictionaryValue> GetDevicesOptions::ToValue() const {
|
|
std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
|
|
|
|
if (this->vendor_id.get()) {
|
|
value->SetWithoutPathExpansion("vendorId", std::make_unique<base::Value>(*this->vendor_id));
|
|
|
|
}
|
|
if (this->product_id.get()) {
|
|
value->SetWithoutPathExpansion("productId", std::make_unique<base::Value>(*this->product_id));
|
|
|
|
}
|
|
if (this->filters.get()) {
|
|
value->SetWithoutPathExpansion("filters", json_schema_compiler::util::CreateValueFromOptionalArray(this->filters));
|
|
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
|
|
DevicePromptOptions::DevicePromptOptions()
|
|
{}
|
|
|
|
DevicePromptOptions::~DevicePromptOptions() {}
|
|
DevicePromptOptions::DevicePromptOptions(DevicePromptOptions&& rhs)
|
|
: multiple(std::move(rhs.multiple)),
|
|
filters(std::move(rhs.filters)){
|
|
}
|
|
|
|
DevicePromptOptions& DevicePromptOptions::operator=(DevicePromptOptions&& rhs)
|
|
{
|
|
multiple = std::move(rhs.multiple);
|
|
filters = std::move(rhs.filters);
|
|
return *this;
|
|
}
|
|
|
|
// static
|
|
bool DevicePromptOptions::Populate(
|
|
const base::Value& value, DevicePromptOptions* out) {
|
|
if (!value.is_dict()) {
|
|
return false;
|
|
}
|
|
const base::DictionaryValue* dict = static_cast<const base::DictionaryValue*>(&value);
|
|
const base::Value* multiple_value = NULL;
|
|
if (dict->GetWithoutPathExpansion("multiple", &multiple_value)) {
|
|
{
|
|
bool temp;
|
|
if (!multiple_value->GetAsBoolean(&temp)) {
|
|
out->multiple.reset();
|
|
return false;
|
|
}
|
|
else
|
|
out->multiple.reset(new bool(temp));
|
|
}
|
|
}
|
|
|
|
const base::Value* filters_value = NULL;
|
|
if (dict->GetWithoutPathExpansion("filters", &filters_value)) {
|
|
{
|
|
const base::ListValue* list = NULL;
|
|
if (!filters_value->GetAsList(&list)) {
|
|
return false;
|
|
}
|
|
else {
|
|
if (!json_schema_compiler::util::PopulateOptionalArrayFromList(*list, &out->filters)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// static
|
|
std::unique_ptr<DevicePromptOptions> DevicePromptOptions::FromValue(const base::Value& value) {
|
|
std::unique_ptr<DevicePromptOptions> out(new DevicePromptOptions());
|
|
if (!Populate(value, out.get()))
|
|
return nullptr;
|
|
return out;
|
|
}
|
|
|
|
std::unique_ptr<base::DictionaryValue> DevicePromptOptions::ToValue() const {
|
|
std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
|
|
|
|
if (this->multiple.get()) {
|
|
value->SetWithoutPathExpansion("multiple", std::make_unique<base::Value>(*this->multiple));
|
|
|
|
}
|
|
if (this->filters.get()) {
|
|
value->SetWithoutPathExpansion("filters", json_schema_compiler::util::CreateValueFromOptionalArray(this->filters));
|
|
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Functions
|
|
//
|
|
|
|
namespace GetDevices {
|
|
|
|
Params::Params() {}
|
|
Params::~Params() {}
|
|
|
|
// static
|
|
std::unique_ptr<Params> Params::Create(const base::ListValue& args) {
|
|
if (args.GetSize() != 1) {
|
|
return nullptr;
|
|
}
|
|
std::unique_ptr<Params> params(new Params());
|
|
|
|
const base::Value* options_value = NULL;
|
|
if (args.Get(0, &options_value) &&
|
|
!options_value->is_none()) {
|
|
{
|
|
const base::DictionaryValue* dictionary = NULL;
|
|
if (!options_value->GetAsDictionary(&dictionary)) {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
if (!GetDevicesOptions::Populate(*dictionary, ¶ms->options)) {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
|
|
return params;
|
|
}
|
|
|
|
|
|
std::unique_ptr<base::ListValue> Results::Create(const std::vector<HidDeviceInfo>& devices) {
|
|
std::unique_ptr<base::ListValue> create_results(new base::ListValue());
|
|
create_results->Append(json_schema_compiler::util::CreateValueFromArray(devices));
|
|
|
|
return create_results;
|
|
}
|
|
} // namespace GetDevices
|
|
|
|
namespace GetUserSelectedDevices {
|
|
|
|
Params::Params() {}
|
|
Params::~Params() {}
|
|
|
|
// static
|
|
std::unique_ptr<Params> Params::Create(const base::ListValue& args) {
|
|
if (args.GetSize() > 1) {
|
|
return nullptr;
|
|
}
|
|
std::unique_ptr<Params> params(new Params());
|
|
|
|
const base::Value* options_value = NULL;
|
|
if (args.Get(0, &options_value) &&
|
|
!options_value->is_none()) {
|
|
{
|
|
const base::DictionaryValue* dictionary = NULL;
|
|
if (!options_value->GetAsDictionary(&dictionary)) {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
else {
|
|
std::unique_ptr<DevicePromptOptions> temp(new DevicePromptOptions());
|
|
if (!DevicePromptOptions::Populate(*dictionary, temp.get())) {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
else
|
|
params->options = std::move(temp);
|
|
}
|
|
}
|
|
}
|
|
|
|
return params;
|
|
}
|
|
|
|
|
|
std::unique_ptr<base::ListValue> Results::Create(const std::vector<HidDeviceInfo>& devices) {
|
|
std::unique_ptr<base::ListValue> create_results(new base::ListValue());
|
|
create_results->Append(json_schema_compiler::util::CreateValueFromArray(devices));
|
|
|
|
return create_results;
|
|
}
|
|
} // namespace GetUserSelectedDevices
|
|
|
|
namespace Connect {
|
|
|
|
Params::Params() {}
|
|
Params::~Params() {}
|
|
|
|
// static
|
|
std::unique_ptr<Params> Params::Create(const base::ListValue& args) {
|
|
if (args.GetSize() != 1) {
|
|
return nullptr;
|
|
}
|
|
std::unique_ptr<Params> params(new Params());
|
|
|
|
const base::Value* device_id_value = NULL;
|
|
if (args.Get(0, &device_id_value) &&
|
|
!device_id_value->is_none()) {
|
|
{
|
|
if (!device_id_value->GetAsInteger(¶ms->device_id)) {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
|
|
return params;
|
|
}
|
|
|
|
|
|
std::unique_ptr<base::ListValue> Results::Create(const HidConnectInfo& connection) {
|
|
std::unique_ptr<base::ListValue> create_results(new base::ListValue());
|
|
create_results->Append((connection).ToValue());
|
|
|
|
return create_results;
|
|
}
|
|
} // namespace Connect
|
|
|
|
namespace Disconnect {
|
|
|
|
Params::Params() {}
|
|
Params::~Params() {}
|
|
|
|
// static
|
|
std::unique_ptr<Params> Params::Create(const base::ListValue& args) {
|
|
if (args.GetSize() != 1) {
|
|
return nullptr;
|
|
}
|
|
std::unique_ptr<Params> params(new Params());
|
|
|
|
const base::Value* connection_id_value = NULL;
|
|
if (args.Get(0, &connection_id_value) &&
|
|
!connection_id_value->is_none()) {
|
|
{
|
|
if (!connection_id_value->GetAsInteger(¶ms->connection_id)) {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
|
|
return params;
|
|
}
|
|
|
|
|
|
std::unique_ptr<base::ListValue> Results::Create() {
|
|
std::unique_ptr<base::ListValue> create_results(new base::ListValue());
|
|
return create_results;
|
|
}
|
|
} // namespace Disconnect
|
|
|
|
namespace Receive {
|
|
|
|
Params::Params() {}
|
|
Params::~Params() {}
|
|
|
|
// static
|
|
std::unique_ptr<Params> Params::Create(const base::ListValue& args) {
|
|
if (args.GetSize() != 1) {
|
|
return nullptr;
|
|
}
|
|
std::unique_ptr<Params> params(new Params());
|
|
|
|
const base::Value* connection_id_value = NULL;
|
|
if (args.Get(0, &connection_id_value) &&
|
|
!connection_id_value->is_none()) {
|
|
{
|
|
if (!connection_id_value->GetAsInteger(¶ms->connection_id)) {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
|
|
return params;
|
|
}
|
|
|
|
|
|
std::unique_ptr<base::ListValue> Results::Create(int report_id, const std::vector<char>& data) {
|
|
std::unique_ptr<base::ListValue> create_results(new base::ListValue());
|
|
create_results->Append(std::make_unique<base::Value>(report_id));
|
|
|
|
create_results->Append(std::make_unique<base::Value>(data));
|
|
|
|
return create_results;
|
|
}
|
|
} // namespace Receive
|
|
|
|
namespace Send {
|
|
|
|
Params::Params() {}
|
|
Params::~Params() {}
|
|
|
|
// static
|
|
std::unique_ptr<Params> Params::Create(const base::ListValue& args) {
|
|
if (args.GetSize() != 3) {
|
|
return nullptr;
|
|
}
|
|
std::unique_ptr<Params> params(new Params());
|
|
|
|
const base::Value* connection_id_value = NULL;
|
|
if (args.Get(0, &connection_id_value) &&
|
|
!connection_id_value->is_none()) {
|
|
{
|
|
if (!connection_id_value->GetAsInteger(¶ms->connection_id)) {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
|
|
const base::Value* report_id_value = NULL;
|
|
if (args.Get(1, &report_id_value) &&
|
|
!report_id_value->is_none()) {
|
|
{
|
|
if (!report_id_value->GetAsInteger(¶ms->report_id)) {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
|
|
const base::Value* data_value = NULL;
|
|
if (args.Get(2, &data_value) &&
|
|
!data_value->is_none()) {
|
|
{
|
|
if (!data_value->is_blob()) {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
else {
|
|
params->data = data_value->GetBlob();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
|
|
return params;
|
|
}
|
|
|
|
|
|
std::unique_ptr<base::ListValue> Results::Create() {
|
|
std::unique_ptr<base::ListValue> create_results(new base::ListValue());
|
|
return create_results;
|
|
}
|
|
} // namespace Send
|
|
|
|
namespace ReceiveFeatureReport {
|
|
|
|
Params::Params() {}
|
|
Params::~Params() {}
|
|
|
|
// static
|
|
std::unique_ptr<Params> Params::Create(const base::ListValue& args) {
|
|
if (args.GetSize() != 2) {
|
|
return nullptr;
|
|
}
|
|
std::unique_ptr<Params> params(new Params());
|
|
|
|
const base::Value* connection_id_value = NULL;
|
|
if (args.Get(0, &connection_id_value) &&
|
|
!connection_id_value->is_none()) {
|
|
{
|
|
if (!connection_id_value->GetAsInteger(¶ms->connection_id)) {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
|
|
const base::Value* report_id_value = NULL;
|
|
if (args.Get(1, &report_id_value) &&
|
|
!report_id_value->is_none()) {
|
|
{
|
|
if (!report_id_value->GetAsInteger(¶ms->report_id)) {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
|
|
return params;
|
|
}
|
|
|
|
|
|
std::unique_ptr<base::ListValue> Results::Create(const std::vector<char>& data) {
|
|
std::unique_ptr<base::ListValue> create_results(new base::ListValue());
|
|
create_results->Append(std::make_unique<base::Value>(data));
|
|
|
|
return create_results;
|
|
}
|
|
} // namespace ReceiveFeatureReport
|
|
|
|
namespace SendFeatureReport {
|
|
|
|
Params::Params() {}
|
|
Params::~Params() {}
|
|
|
|
// static
|
|
std::unique_ptr<Params> Params::Create(const base::ListValue& args) {
|
|
if (args.GetSize() != 3) {
|
|
return nullptr;
|
|
}
|
|
std::unique_ptr<Params> params(new Params());
|
|
|
|
const base::Value* connection_id_value = NULL;
|
|
if (args.Get(0, &connection_id_value) &&
|
|
!connection_id_value->is_none()) {
|
|
{
|
|
if (!connection_id_value->GetAsInteger(¶ms->connection_id)) {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
|
|
const base::Value* report_id_value = NULL;
|
|
if (args.Get(1, &report_id_value) &&
|
|
!report_id_value->is_none()) {
|
|
{
|
|
if (!report_id_value->GetAsInteger(¶ms->report_id)) {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
|
|
const base::Value* data_value = NULL;
|
|
if (args.Get(2, &data_value) &&
|
|
!data_value->is_none()) {
|
|
{
|
|
if (!data_value->is_blob()) {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
else {
|
|
params->data = data_value->GetBlob();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
return std::unique_ptr<Params>();
|
|
}
|
|
|
|
return params;
|
|
}
|
|
|
|
|
|
std::unique_ptr<base::ListValue> Results::Create() {
|
|
std::unique_ptr<base::ListValue> create_results(new base::ListValue());
|
|
return create_results;
|
|
}
|
|
} // namespace SendFeatureReport
|
|
|
|
//
|
|
// Events
|
|
//
|
|
|
|
namespace OnDeviceAdded {
|
|
|
|
const char kEventName[] = "hid.onDeviceAdded";
|
|
|
|
std::unique_ptr<base::ListValue> Create(const HidDeviceInfo& device) {
|
|
std::unique_ptr<base::ListValue> create_results(new base::ListValue());
|
|
create_results->Append((device).ToValue());
|
|
|
|
return create_results;
|
|
}
|
|
|
|
} // namespace OnDeviceAdded
|
|
|
|
namespace OnDeviceRemoved {
|
|
|
|
const char kEventName[] = "hid.onDeviceRemoved";
|
|
|
|
std::unique_ptr<base::ListValue> Create(int device_id) {
|
|
std::unique_ptr<base::ListValue> create_results(new base::ListValue());
|
|
create_results->Append(std::make_unique<base::Value>(device_id));
|
|
|
|
return create_results;
|
|
}
|
|
|
|
} // namespace OnDeviceRemoved
|
|
|
|
} // namespace hid
|
|
} // namespace api
|
|
} // namespace extensions
|
|
|