Comparar texto

Encuentra la diferencia entre dos archivos de texto

Editor live
Ocultar sin cambios
Sin ajuste de línea
Vista
Nivel de detalle
Resaltado de sintaxis

Untitled diff

Creado El diff nunca expira
186 eliminaciones
814 líneas
166 adiciones
766 líneas
// Copyright (c) 2019 The Chromium Authors. All rights reserved.
// Copyright (c) 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// found in the LICENSE file.
// GENERATED FROM THE API DEFINITION IN
// GENERATED FROM THE API DEFINITION IN
// extensions/common/api/declarative_net_request.idl
// extensions/common/api/declarative_net_request.idl
// DO NOT EDIT.
// DO NOT EDIT.
#include "tools/json_schema_compiler/util.h"
#include "tools/json_schema_compiler/util.h"
#include "base/logging.h"
#include "base/logging.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "base/values.h"
#include "base/values.h"
#include "extensions/common/api/declarative_net_request.h"
#include "extensions/common/api/declarative_net_request.h"
#include <set>
#include <set>
#include <utility>
#include <utility>
using base::UTF8ToUTF16;
using base::UTF8ToUTF16;
namespace extensions {
namespace extensions {
namespace api {
namespace api {
namespace declarative_net_request {
namespace declarative_net_request {
//
//
// Properties
// Properties
//
//
const int MAX_NUMBER_OF_ALLOWED_PAGES = 100;
const int MAX_NUMBER_OF_ALLOWED_PAGES = 100;
const int MAX_NUMBER_OF_RULES = 30000;
const int MAX_NUMBER_OF_RULES = 30000;
//
//
// Types
// Types
//
//
const char* ToString(ResourceType enum_param) {
const char* ToString(ResourceType enum_param) {
switch (enum_param) {
switch (enum_param) {
case RESOURCE_TYPE_MAIN_FRAME:
case RESOURCE_TYPE_MAIN_FRAME:
return "main_frame";
return "main_frame";
case RESOURCE_TYPE_SUB_FRAME:
case RESOURCE_TYPE_SUB_FRAME:
return "sub_frame";
return "sub_frame";
case RESOURCE_TYPE_STYLESHEET:
case RESOURCE_TYPE_STYLESHEET:
return "stylesheet";
return "stylesheet";
case RESOURCE_TYPE_SCRIPT:
case RESOURCE_TYPE_SCRIPT:
return "script";
return "script";
case RESOURCE_TYPE_IMAGE:
case RESOURCE_TYPE_IMAGE:
return "image";
return "image";
case RESOURCE_TYPE_FONT:
case RESOURCE_TYPE_FONT:
return "font";
return "font";
case RESOURCE_TYPE_OBJECT:
case RESOURCE_TYPE_OBJECT:
return "object";
return "object";
case RESOURCE_TYPE_XMLHTTPREQUEST:
case RESOURCE_TYPE_XMLHTTPREQUEST:
return "xmlhttprequest";
return "xmlhttprequest";
case RESOURCE_TYPE_PING:
case RESOURCE_TYPE_PING:
return "ping";
return "ping";
case RESOURCE_TYPE_CSP_REPORT:
case RESOURCE_TYPE_CSP_REPORT:
return "csp_report";
return "csp_report";
case RESOURCE_TYPE_MEDIA:
case RESOURCE_TYPE_MEDIA:
return "media";
return "media";
case RESOURCE_TYPE_WEBSOCKET:
case RESOURCE_TYPE_WEBSOCKET:
return "websocket";
return "websocket";
case RESOURCE_TYPE_OTHER:
case RESOURCE_TYPE_OTHER:
return "other";
return "other";
case RESOURCE_TYPE_NONE:
case RESOURCE_TYPE_NONE:
return "";
return "";
}
}
NOTREACHED();
NOTREACHED();
return "";
return "";
}
}
ResourceType ParseResourceType(const std::string& enum_string) {
ResourceType ParseResourceType(const std::string& enum_string) {
if (enum_string == "main_frame")
if (enum_string == "main_frame")
return RESOURCE_TYPE_MAIN_FRAME;
return RESOURCE_TYPE_MAIN_FRAME;
if (enum_string == "sub_frame")
if (enum_string == "sub_frame")
return RESOURCE_TYPE_SUB_FRAME;
return RESOURCE_TYPE_SUB_FRAME;
if (enum_string == "stylesheet")
if (enum_string == "stylesheet")
return RESOURCE_TYPE_STYLESHEET;
return RESOURCE_TYPE_STYLESHEET;
if (enum_string == "script")
if (enum_string == "script")
return RESOURCE_TYPE_SCRIPT;
return RESOURCE_TYPE_SCRIPT;
if (enum_string == "image")
if (enum_string == "image")
return RESOURCE_TYPE_IMAGE;
return RESOURCE_TYPE_IMAGE;
if (enum_string == "font")
if (enum_string == "font")
return RESOURCE_TYPE_FONT;
return RESOURCE_TYPE_FONT;
if (enum_string == "object")
if (enum_string == "object")
return RESOURCE_TYPE_OBJECT;
return RESOURCE_TYPE_OBJECT;
if (enum_string == "xmlhttprequest")
if (enum_string == "xmlhttprequest")
return RESOURCE_TYPE_XMLHTTPREQUEST;
return RESOURCE_TYPE_XMLHTTPREQUEST;
if (enum_string == "ping")
if (enum_string == "ping")
return RESOURCE_TYPE_PING;
return RESOURCE_TYPE_PING;
if (enum_string == "csp_report")
if (enum_string == "csp_report")
return RESOURCE_TYPE_CSP_REPORT;
return RESOURCE_TYPE_CSP_REPORT;
if (enum_string == "media")
if (enum_string == "media")
return RESOURCE_TYPE_MEDIA;
return RESOURCE_TYPE_MEDIA;
if (enum_string == "websocket")
if (enum_string == "websocket")
return RESOURCE_TYPE_WEBSOCKET;
return RESOURCE_TYPE_WEBSOCKET;
if (enum_string == "other")
if (enum_string == "other")
return RESOURCE_TYPE_OTHER;
return RESOURCE_TYPE_OTHER;
return RESOURCE_TYPE_NONE;
return RESOURCE_TYPE_NONE;
}
}
const char* ToString(DomainType enum_param) {
const char* ToString(DomainType enum_param) {
switch (enum_param) {
switch (enum_param) {
case DOMAIN_TYPE_FIRSTPARTY:
case DOMAIN_TYPE_FIRSTPARTY:
return "firstParty";
return "firstParty";
case DOMAIN_TYPE_THIRDPARTY:
case DOMAIN_TYPE_THIRDPARTY:
return "thirdParty";
return "thirdParty";
case DOMAIN_TYPE_NONE:
case DOMAIN_TYPE_NONE:
return "";
return "";
}
}
NOTREACHED();
NOTREACHED();
return "";
return "";
}
}
DomainType ParseDomainType(const std::string& enum_string) {
DomainType ParseDomainType(const std::string& enum_string) {
if (enum_string == "firstParty")
if (enum_string == "firstParty")
return DOMAIN_TYPE_FIRSTPARTY;
return DOMAIN_TYPE_FIRSTPARTY;
if (enum_string == "thirdParty")
if (enum_string == "thirdParty")
return DOMAIN_TYPE_THIRDPARTY;
return DOMAIN_TYPE_THIRDPARTY;
return DOMAIN_TYPE_NONE;
return DOMAIN_TYPE_NONE;
}
}
const char* ToString(RuleActionType enum_param) {
const char* ToString(RuleActionType enum_param) {
switch (enum_param) {
switch (enum_param) {
case RULE_ACTION_TYPE_BLOCK:
case RULE_ACTION_TYPE_BLOCK:
return "block";
return "block";
case RULE_ACTION_TYPE_REDIRECT:
case RULE_ACTION_TYPE_REDIRECT:
return "redirect";
return "redirect";
case RULE_ACTION_TYPE_ALLOW:
case RULE_ACTION_TYPE_ALLOW:
return "allow";
return "allow";
case RULE_ACTION_TYPE_NONE:
case RULE_ACTION_TYPE_NONE:
return "";
return "";
}
}
NOTREACHED();
NOTREACHED();
return "";
return "";
}
}
RuleActionType ParseRuleActionType(const std::string& enum_string) {
RuleActionType ParseRuleActionType(const std::string& enum_string) {
if (enum_string == "block")
if (enum_string == "block")
return RULE_ACTION_TYPE_BLOCK;
return RULE_ACTION_TYPE_BLOCK;
if (enum_string == "redirect")
if (enum_string == "redirect")
return RULE_ACTION_TYPE_REDIRECT;
return RULE_ACTION_TYPE_REDIRECT;
if (enum_string == "allow")
if (enum_string == "allow")
return RULE_ACTION_TYPE_ALLOW;
return RULE_ACTION_TYPE_ALLOW;
return RULE_ACTION_TYPE_NONE;
return RULE_ACTION_TYPE_NONE;
}
}
RuleCondition::RuleCondition()
RuleCondition::RuleCondition()
: domain_type(DOMAIN_TYPE_NONE) {}
: domain_type(DOMAIN_TYPE_NONE) {}
RuleCondition::~RuleCondition() {}
RuleCondition::~RuleCondition() {}
RuleCondition::RuleCondition(RuleCondition&& rhs)
RuleCondition::RuleCondition(RuleCondition&& rhs)
: url_filter(std::move(rhs.url_filter)),
: url_filter(std::move(rhs.url_filter)),
is_url_filter_case_sensitive(std::move(rhs.is_url_filter_case_sensitive)),
is_url_filter_case_sensitive(std::move(rhs.is_url_filter_case_sensitive)),
domains(std::move(rhs.domains)),
domains(std::move(rhs.domains)),
excluded_domains(std::move(rhs.excluded_domains)),
excluded_domains(std::move(rhs.excluded_domains)),
resource_types(std::move(rhs.resource_types)),
resource_types(std::move(rhs.resource_types)),
excluded_resource_types(std::move(rhs.excluded_resource_types)),
excluded_resource_types(std::move(rhs.excluded_resource_types)),
domain_type(rhs.domain_type){
domain_type(rhs.domain_type){
}
}
RuleCondition& RuleCondition::operator=(RuleCondition&& rhs)
RuleCondition& RuleCondition::operator=(RuleCondition&& rhs)
{
{
url_filter = std::move(rhs.url_filter);
url_filter = std::move(rhs.url_filter);
is_url_filter_case_sensitive = std::move(rhs.is_url_filter_case_sensitive);
is_url_filter_case_sensitive = std::move(rhs.is_url_filter_case_sensitive);
domains = std::move(rhs.domains);
domains = std::move(rhs.domains);
excluded_domains = std::move(rhs.excluded_domains);
excluded_domains = std::move(rhs.excluded_domains);
resource_types = std::move(rhs.resource_types);
resource_types = std::move(rhs.resource_types);
excluded_resource_types = std::move(rhs.excluded_resource_types);
excluded_resource_types = std::move(rhs.excluded_resource_types);
domain_type = rhs.domain_type;
domain_type = rhs.domain_type;
return *this;
return *this;
}
}
// static
// static
bool RuleCondition::Populate(
bool RuleCondition::Populate(
const base::Value& value, RuleCondition* out) {
const base::Value& value, RuleCondition* out, base::string16* error) {
DCHECK(error);
if (!value.is_dict()) {
if (!value.is_dict()) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("expected dictionary, got " + std::string(base::Value::GetTypeName(value.type()))));
return false;
return false;
}
}
const base::DictionaryValue* dict = static_cast<const base::DictionaryValue*>(&value);
const base::DictionaryValue* dict = static_cast<const base::DictionaryValue*>(&value);
std::set<std::string> keys;
out->domain_type = DOMAIN_TYPE_NONE;
out->domain_type = DOMAIN_TYPE_NONE;
keys.insert("urlFilter");
const base::Value* url_filter_value = NULL;
const base::Value* url_filter_value = NULL;
if (dict->GetWithoutPathExpansion("urlFilter", &url_filter_value)) {
if (dict->GetWithoutPathExpansion("urlFilter", &url_filter_value)) {
{
{
std::string temp;
std::string temp;
if (!url_filter_value->GetAsString(&temp)) {
if (!url_filter_value->GetAsString(&temp)) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'urlFilter': expected urlFilter, got " + std::string(base::Value::GetTypeName(url_filter_value->type()))));
out->url_filter.reset();
out->url_filter.reset();
return false;
}
}
else
else
out->url_filter.reset(new std::string(temp));
out->url_filter.reset(new std::string(temp));
}
}
}
}
keys.insert("isUrlFilterCaseSensitive");
const base::Value* is_url_filter_case_sensitive_value = NULL;
const base::Value* is_url_filter_case_sensitive_value = NULL;
if (dict->GetWithoutPathExpansion("isUrlFilterCaseSensitive", &is_url_filter_case_sensitive_value)) {
if (dict->GetWithoutPathExpansion("isUrlFilterCaseSensitive", &is_url_filter_case_sensitive_value)) {
{
{
bool temp;
bool temp;
if (!is_url_filter_case_sensitive_value->GetAsBoolean(&temp)) {
if (!is_url_filter_case_sensitive_value->GetAsBoolean(&temp)) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'isUrlFilterCaseSensitive': expected isUrlFilterCaseSensitive, got " + std::string(base::Value::GetTypeName(is_url_filter_case_sensitive_value->type()))));
out->is_url_filter_case_sensitive.reset();
out->is_url_filter_case_sensitive.reset();
return false;
}
}
else
else
out->is_url_filter_case_sensitive.reset(new bool(temp));
out->is_url_filter_case_sensitive.reset(new bool(temp));
}
}
}
}
keys.insert("domains");
const base::Value* domains_value = NULL;
const base::Value* domains_value = NULL;
if (dict->GetWithoutPathExpansion("domains", &domains_value)) {
if (dict->GetWithoutPathExpansion("domains", &domains_value)) {
{
{
const base::ListValue* list = NULL;
const base::ListValue* list = NULL;
if (!domains_value->GetAsList(&list)) {
if (!domains_value->GetAsList(&list)) {
return false;
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'domains': expected list, got " + std::string(base::Value::GetTypeName(domains_value->type()))));
out->domains.reset();
}
}
else {
else {
if (!json_schema_compiler::util::PopulateOptionalArrayFromList(*list, &out->domains)) {
if (!json_schema_compiler::util::PopulateOptionalArrayFromList(*list, &out->domains, error)) {
return false;
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("unable to populate array 'RuleCondition'"));
out->domains.reset();
}
}
}
}
}
}
}
}
keys.insert("excludedDomains");
const base::Value* excluded_domains_value = NULL;
const base::Value* excluded_domains_value = NULL;
if (dict->GetWithoutPathExpansion("excludedDomains", &excluded_domains_value)) {
if (dict->GetWithoutPathExpansion("excludedDomains", &excluded_domains_value)) {
{
{
const base::ListValue* list = NULL;
const base::ListValue* list = NULL;
if (!excluded_domains_value->GetAsList(&list)) {
if (!excluded_domains_value->GetAsList(&list)) {
return false;
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'excludedDomains': expected list, got " + std::string(base::Value::GetTypeName(excluded_domains_value->type()))));
out->excluded_domains.reset();
}
}
else {
else {
if (!json_schema_compiler::util::PopulateOptionalArrayFromList(*list, &out->excluded_domains)) {
if (!json_schema_compiler::util::PopulateOptionalArrayFromList(*list, &out->excluded_domains, error)) {
return false;
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("unable to populate array 'RuleCondition'"));
out->excluded_domains.reset();
}
}
}
}
}
}
}
}
keys.insert("resourceTypes");
const base::Value* resource_types_value = NULL;
const base::Value* resource_types_value = NULL;
if (dict->GetWithoutPathExpansion("resourceTypes", &resource_types_value)) {
if (dict->GetWithoutPathExpansion("resourceTypes", &resource_types_value)) {
{
{
const base::ListValue* list = NULL;
const base::ListValue* list = NULL;
if (!resource_types_value->GetAsList(&list)) {
if (!resource_types_value->GetAsList(&list)) {
return false;
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'resourceTypes': expected list, got " + std::string(base::Value::GetTypeName(resource_types_value->type()))));
out->resource_types.reset();
}
}
else {
else {
out->resource_types.reset(new std::vector<ResourceType>);
out->resource_types.reset(new std::vector<ResourceType>);
for (const auto& it : *(list)) {
for (const auto& it : *(list)) {
ResourceType tmp;
ResourceType tmp;
std::string resource_type_as_string;
std::string resource_type_as_string;
if (!(it).GetAsString(&resource_type_as_string)) {
if (!(it).GetAsString(&resource_type_as_string)) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'ResourceType': expected string, got " + std::string(base::Value::GetTypeName((it).type()))));
return false;
return false;
}
}
tmp = ParseResourceType(resource_type_as_string);
tmp = ParseResourceType(resource_type_as_string);
if (tmp == RESOURCE_TYPE_NONE) {
if (tmp == RESOURCE_TYPE_NONE) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'ResourceType': expected \"main_frame\" or \"sub_frame\" or \"stylesheet\" or \"script\" or \"image\" or \"font\" or \"object\" or \"xmlhttprequest\" or \"ping\" or \"csp_report\" or \"media\" or \"websocket\" or \"other\", got \"" + resource_type_as_string + "\""));
return false;
return false;
}
}
out->resource_types->push_back(tmp);
out->resource_types->push_back(tmp);
}
}
}
}
}
}
}
}
keys.insert("excludedResourceTypes");
const base::Value* excluded_resource_types_value = NULL;
const base::Value* excluded_resource_types_value = NULL;
if (dict->GetWithoutPathExpansion("excludedResourceTypes", &excluded_resource_types_value)) {
if (dict->GetWithoutPathExpansion("excludedResourceTypes", &excluded_resource_types_value)) {
{
{
const base::ListValue* list = NULL;
const base::ListValue* list = NULL;
if (!excluded_resource_types_value->GetAsList(&list)) {
if (!excluded_resource_types_value->GetAsList(&list)) {
return false;
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'excludedResourceTypes': expected list, got " + std::string(base::Value::GetTypeName(excluded_resource_types_value->type()))));
out->excluded_resource_types.reset();
}
}
else {
else {
out->excluded_resource_types.reset(new std::vector<ResourceType>);
out->excluded_resource_types.reset(new std::vector<ResourceType>);
for (const auto& it : *(list)) {
for (const auto& it : *(list)) {
ResourceType tmp;
ResourceType tmp;
std::string resource_type_as_string;
std::string resource_type_as_string;
if (!(it).GetAsString(&resource_type_as_string)) {
if (!(it).GetAsString(&resource_type_as_string)) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'ResourceType': expected string, got " + std::string(base::Value::GetTypeName((it).type()))));
return false;
return false;
}
}
tmp = ParseResourceType(resource_type_as_string);
tmp = ParseResourceType(resource_type_as_string);
if (tmp == RESOURCE_TYPE_NONE) {
if (tmp == RESOURCE_TYPE_NONE) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'ResourceType': expected \"main_frame\" or \"sub_frame\" or \"stylesheet\" or \"script\" or \"image\" or \"font\" or \"object\" or \"xmlhttprequest\" or \"ping\" or \"csp_report\" or \"media\" or \"websocket\" or \"other\", got \"" + resource_type_as_string + "\""));
return false;
return false;
}
}
out->excluded_resource_types->push_back(tmp);
out->excluded_resource_types->push_back(tmp);
}
}
}
}
}
}
}
}
keys.insert("domainType");
const base::Value* domain_type_value = NULL;
const base::Value* domain_type_value = NULL;
if (dict->GetWithoutPathExpansion("domainType", &domain_type_value)) {
if (dict->GetWithoutPathExpansion("domainType", &domain_type_value)) {
{
{
std::string domain_type_as_string;
std::string domain_type_as_string;
if (!domain_type_value->GetAsString(&domain_type_as_string)) {
if (!domain_type_value->GetAsString(&domain_type_as_string)) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'DomainType': expected string, got " + std::string(base::Value::GetTypeName(domain_type_value->type()))));
return false;
return false;
}
}
out->domain_type = ParseDomainType(domain_type_as_string);
out->domain_type = ParseDomainType(domain_type_as_string);
if (out->domain_type == DOMAIN_TYPE_NONE) {
if (out->domain_type == DOMAIN_TYPE_NONE) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'DomainType': expected \"firstParty\" or \"thirdParty\", got \"" + domain_type_as_string + "\""));
return false;
return false;
}
}
}
}
} else {
} else {
out->domain_type = DOMAIN_TYPE_NONE;
out->domain_type = DOMAIN_TYPE_NONE;
}
}
for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
if (!keys.count(it.key())) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("found unexpected key '" + it.key() + "'"));
}
}
return true;
return true;
}
}
// static
// static
std::unique_ptr<RuleCondition> RuleCondition::FromValue(const base::Value& value) {
std::unique_ptr<RuleCondition> RuleCondition::FromValue(const base::Value& value, base::string16* error) {
DCHECK(error);
std::unique_ptr<RuleCondition> out(new RuleCondition());
std::unique_ptr<RuleCondition> out(new RuleCondition());
if (!Populate(value, out.get()))
if (!Populate(value, out.get(), error))
return nullptr;
return nullptr;
return out;
return out;
}
}
std::unique_ptr<base::DictionaryValue> RuleCondition::ToValue() const {
std::unique_ptr<base::DictionaryValue> RuleCondition::ToValue() const {
std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
if (this->url_filter.get()) {
if (this->url_filter.get()) {
value->SetWithoutPathExpansion("urlFilter", std::make_unique<base::Value>(*this->url_filter));
value->SetWithoutPathExpansion("urlFilter", std::make_unique<base::Value>(*this->url_filter));
}
}
if (this->is_url_filter_case_sensitive.get()) {
if (this->is_url_filter_case_sensitive.get()) {
value->SetWithoutPathExpansion("isUrlFilterCaseSensitive", std::make_unique<base::Value>(*this->is_url_filter_case_sensitive));
value->SetWithoutPathExpansion("isUrlFilterCaseSensitive", std::make_unique<base::Value>(*this->is_url_filter_case_sensitive));
}
}
if (this->domains.get()) {
if (this->domains.get()) {
value->SetWithoutPathExpansion("domains", json_schema_compiler::util::CreateValueFromOptionalArray(this->domains));
value->SetWithoutPathExpansion("domains", json_schema_compiler::util::CreateValueFromOptionalArray(this->domains));
}
}
if (this->excluded_domains.get()) {
if (this->excluded_domains.get()) {
value->SetWithoutPathExpansion("excludedDomains", json_schema_compiler::util::CreateValueFromOptionalArray(this->excluded_domains));
value->SetWithoutPathExpansion("excludedDomains", json_schema_compiler::util::CreateValueFromOptionalArray(this->excluded_domains));
}
}
if (this->resource_types.get()) {
if (this->resource_types.get()) {
{
{
std::vector<std::string> resourceTypes_list;
std::vector<std::string> resourceTypes_list;
for (const auto& it : *(this->resource_types)) {
for (const auto& it : *(this->resource_types)) {
resourceTypes_list.push_back(declarative_net_request::ToString(it));
resourceTypes_list.push_back(declarative_net_request::ToString(it));
}
}
value->SetWithoutPathExpansion("resourceTypes", json_schema_compiler::util::CreateValueFromArray(resourceTypes_list));
value->SetWithoutPathExpansion("resourceTypes", json_schema_compiler::util::CreateValueFromArray(resourceTypes_list));
}
}
}
}
if (this->excluded_resource_types.get()) {
if (this->excluded_resource_types.get()) {
{
{
std::vector<std::string> excludedResourceTypes_list;
std::vector<std::string> excludedResourceTypes_list;
for (const auto& it : *(this->excluded_resource_types)) {
for (const auto& it : *(this->excluded_resource_types)) {
excludedResourceTypes_list.push_back(declarative_net_request::ToString(it));
excludedResourceTypes_list.push_back(declarative_net_request::ToString(it));
}
}
value->SetWithoutPathExpansion("excludedResourceTypes", json_schema_compiler::util::CreateValueFromArray(excludedResourceTypes_list));
value->SetWithoutPathExpansion("excludedResourceTypes", json_schema_compiler::util::CreateValueFromArray(excludedResourceTypes_list));
}
}
}
}
if (this->domain_type != DOMAIN_TYPE_NONE) {
if (this->domain_type != DOMAIN_TYPE_NONE) {
value->SetWithoutPathExpansion("domainType", std::make_unique<base::Value>(declarative_net_request::ToString(this->domain_type)));
value->SetWithoutPathExpansion("domainType", std::make_unique<base::Value>(declarative_net_request::ToString(this->domain_type)));
}
}
return value;
return value;
}
}
RuleAction::RuleAction()
RuleAction::RuleAction()
: type(RULE_ACTION_TYPE_NONE) {}
: type(RULE_ACTION_TYPE_NONE) {}
RuleAction::~RuleAction() {}
RuleAction::~RuleAction() {}
RuleAction::RuleAction(RuleAction&& rhs)
RuleAction::RuleAction(RuleAction&& rhs)
: type(rhs.type),
: type(rhs.type),
redirect_url(std::move(rhs.redirect_url)){
redirect_url(std::move(rhs.redirect_url)){
}
}
RuleAction& RuleAction::operator=(RuleAction&& rhs)
RuleAction& RuleAction::operator=(RuleAction&& rhs)
{
{
type = rhs.type;
type = rhs.type;
redirect_url = std::move(rhs.redirect_url);
redirect_url = std::move(rhs.redirect_url);
return *this;
return *this;
}
}
// static
// static
bool RuleAction::Populate(
bool RuleAction::Populate(
const base::Value& value, RuleAction* out) {
const base::Value& value, RuleAction* out, base::string16* error) {
DCHECK(error);
if (!value.is_dict()) {
if (!value.is_dict()) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("expected dictionary, got " + std::string(base::Value::GetTypeName(value.type()))));
return false;
return false;
}
}
const base::DictionaryValue* dict = static_cast<const base::DictionaryValue*>(&value);
const base::DictionaryValue* dict = static_cast<const base::DictionaryValue*>(&value);
std::set<std::string> keys;
keys.insert("type");
const base::Value* type_value = NULL;
const base::Value* type_value = NULL;
if (!dict->GetWithoutPathExpansion("type", &type_value)) {
if (!dict->GetWithoutPathExpansion("type", &type_value)) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'type' is required"));
return false;
return false;
}
}
{
{
std::string rule_action_type_as_string;
std::string rule_action_type_as_string;
if (!type_value->GetAsString(&rule_action_type_as_string)) {
if (!type_value->GetAsString(&rule_action_type_as_string)) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'RuleActionType': expected string, got " + std::string(base::Value::GetTypeName(type_value->type()))));
return false;
return false;
}
}
out->type = ParseRuleActionType(rule_action_type_as_string);
out->type = ParseRuleActionType(rule_action_type_as_string);
if (out->type == RULE_ACTION_TYPE_NONE) {
if (out->type == RULE_ACTION_TYPE_NONE) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'RuleActionType': expected \"block\" or \"redirect\" or \"allow\", got \"" + rule_action_type_as_string + "\""));
return false;
return false;
}
}
}
}
keys.insert("redirectUrl");
const base::Value* redirect_url_value = NULL;
const base::Value* redirect_url_value = NULL;
if (dict->GetWithoutPathExpansion("redirectUrl", &redirect_url_value)) {
if (dict->GetWithoutPathExpansion("redirectUrl", &redirect_url_value)) {
{
{
std::string temp;
std::string temp;
if (!redirect_url_value->GetAsString(&temp)) {
if (!redirect_url_value->GetAsString(&temp)) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'redirectUrl': expected redirectUrl, got " + std::string(base::Value::GetTypeName(redirect_url_value->type()))));
out->redirect_url.reset();
out->redirect_url.reset();
return false;
}
}
else
else
out->redirect_url.reset(new std::string(temp));
out->redirect_url.reset(new std::string(temp));
}
}
}
}
for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
if (!keys.count(it.key())) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("found unexpected key '" + it.key() + "'"));
}
}
return true;
return true;
}
}
// static
// static
std::unique_ptr<RuleAction> RuleAction::FromValue(const base::Value& value) {
std::unique_ptr<RuleAction> RuleAction::FromValue(const base::Value& value, base::string16* error) {
DCHECK(error);
std::unique_ptr<RuleAction> out(new RuleAction());
std::unique_ptr<RuleAction> out(new RuleAction());
if (!Populate(value, out.get()))
if (!Populate(value, out.get(), error))
return nullptr;
return nullptr;
return out;
return out;
}
}
std::unique_ptr<base::DictionaryValue> RuleAction::ToValue() const {
std::unique_ptr<base::DictionaryValue> RuleAction::ToValue() const {
std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
value->SetWithoutPathExpansion("type", std::make_unique<base::Value>(declarative_net_request::ToString(this->type)));
value->SetWithoutPathExpansion("type", std::make_unique<base::Value>(declarative_net_request::ToString(this->type)));
if (this->redirect_url.get()) {
if (this->redirect_url.get()) {
value->SetWithoutPathExpansion("redirectUrl", std::make_unique<base::Value>(*this->redirect_url));
value->SetWithoutPathExpansion("redirectUrl", std::make_unique<base::Value>(*this->redirect_url));
}
}
return value;
return value;
}
}
Rule::Rule()
Rule::Rule()
: id(0) {}
: id(0) {}
Rule::~Rule() {}
Rule::~Rule() {}
Rule::Rule(Rule&& rhs)
Rule::Rule(Rule&& rhs)
: id(rhs.id),
: id(rhs.id),
priority(std::move(rhs.priority)),
priority(std::move(rhs.priority)),
condition(std::move(rhs.condition)),
condition(std::move(rhs.condition)),
action(std::move(rhs.action)){
action(std::move(rhs.action)){
}
}
Rule& Rule::operator=(Rule&& rhs)
Rule& Rule::operator=(Rule&& rhs)
{
{
id = rhs.id;
id = rhs.id;
priority = std::move(rhs.priority);
priority = std::move(rhs.priority);
condition = std::move(rhs.condition);
condition = std::move(rhs.condition);
action = std::move(rhs.action);
action = std::move(rhs.action);
return *this;
return *this;
}
}
// static
// static
bool Rule::Populate(
bool Rule::Populate(
const base::Value& value, Rule* out) {
const base::Value& value, Rule* out, base::string16* error) {
DCHECK(error);
if (!value.is_dict()) {
if (!value.is_dict()) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("expected dictionary, got " + std::string(base::Value::GetTypeName(value.type()))));
return false;
return false;
}
}
const base::DictionaryValue* dict = static_cast<const base::DictionaryValue*>(&value);
const base::DictionaryValue* dict = static_cast<const base::DictionaryValue*>(&value);
std::set<std::string> keys;
keys.insert("id");
const base::Value* id_value = NULL;
const base::Value* id_value = NULL;
if (!dict->GetWithoutPathExpansion("id", &id_value)) {
if (!dict->GetWithoutPathExpansion("id", &id_value)) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'id' is required"));
return false;
return false;
}
}
{
{
if (!id_value->GetAsInteger(&out->id)) {
if (!id_value->GetAsInteger(&out->id)) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'id': expected id, got " + std::string(base::Value::GetTypeName(id_value->type()))));
return false;
return false;
}
}
}
}
keys.insert("priority");
const base::Value* priority_value = NULL;
const base::Value* priority_value = NULL;
if (dict->GetWithoutPathExpansion("priority", &priority_value)) {
if (dict->GetWithoutPathExpansion("priority", &priority_value)) {
{
{
int temp;
int temp;
if (!priority_value->GetAsInteger(&temp)) {
if (!priority_value->GetAsInteger(&temp)) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'priority': expected priority, got " + std::string(base::Value::GetTypeName(priority_value->type()))));
out->priority.reset();
out->priority.reset();
return false;
}
}
else
else
out->priority.reset(new int(temp));
out->priority.reset(new int(temp));
}
}
}
}
keys.insert("condition");
const base::Value* condition_value = NULL;
const base::Value* condition_value = NULL;
if (!dict->GetWithoutPathExpansion("condition", &condition_value)) {
if (!dict->GetWithoutPathExpansion("condition", &condition_value)) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'condition' is required"));
return false;
return false;
}
}
{
{
const base::DictionaryValue* dictionary = NULL;
const base::DictionaryValue* dictionary = NULL;
if (!condition_value->GetAsDictionary(&dictionary)) {
if (!condition_value->GetAsDictionary(&dictionary)) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'condition': expected dictionary, got " + std::string(base::Value::GetTypeName(condition_value->type()))));
return false;
return false;
}
}
if (!RuleCondition::Populate(*dictionary, &out->condition)) {
if (!RuleCondition::Populate(*dictionary, &out->condition, error)) {
return false;
return false;
}
}
}
}
keys.insert("action");
const base::Value* action_value = NULL;
const base::Value* action_value = NULL;
if (!dict->GetWithoutPathExpansion("action", &action_value)) {
if (!dict->GetWithoutPathExpansion("action", &action_value)) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'action' is required"));
return false;
return false;
}
}
{
{
const base::DictionaryValue* dictionary = NULL;
const base::DictionaryValue* dictionary = NULL;
if (!action_value->GetAsDictionary(&dictionary)) {
if (!action_value->GetAsDictionary(&dictionary)) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'action': expected dictionary, got " + std::string(base::Value::GetTypeName(action_value->type()))));
return false;
return false;
}
}
if (!RuleAction::Populate(*dictionary, &out->action)) {
if (!RuleAction::Populate(*dictionary, &out->action, error)) {
return false;
return false;
}
}
}
}
for (base::DictionaryValue::Iterator it(*dict); !it.IsAtEnd(); it.Advance()) {
if (!keys.count(it.key())) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("found unexpected key '" + it.key() + "'"));
}
}
return true;
return true;
}
}
// static
// static
std::unique_ptr<Rule> Rule::FromValue(const base::Value& value) {
std::unique_ptr<Rule> Rule::FromValue(const base::Value& value, base::string16* error) {
DCHECK(error);
std::unique_ptr<Rule> out(new Rule());
std::unique_ptr<Rule> out(new Rule());
if (!Populate(value, out.get()))
if (!Populate(value, out.get(), error))
return nullptr;
return nullptr;
return out;
return out;
}
}
std::unique_ptr<base::DictionaryValue> Rule::ToValue() const {
std::unique_ptr<base::DictionaryValue> Rule::ToValue() const {
std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
value->SetWithoutPathExpansion("id", std::make_unique<base::Value>(this->id));
value->SetWithoutPathExpansion("id", std::make_unique<base::Value>(this->id));
if (this->priority.get()) {
if (this->priority.get()) {
value->SetWithoutPathExpansion("priority", std::make_unique<base::Value>(*this->priority));
value->SetWithoutPathExpansion("priority", std::make_unique<base::Value>(*this->priority));
}
}
value->SetWithoutPathExpansion("condition", (this->condition).ToValue());
value->SetWithoutPathExpansion("condition", (this->condition).ToValue());
value->SetWithoutPathExpansion("action", (this->action).ToValue());
value->SetWithoutPathExpansion("action", (this->action).ToValue());
return value;
return value;
}
}
//
//
// Functions
// Functions
//
//
namespace AddAllowedPages {
namespace AddAllowedPages {
Params::Params() {}
Params::Params() {}
Params::~Params() {}
Params::~Params() {}
// static
// static
std::unique_ptr<Params> Params::Create(const base::ListValue& args) {
std::unique_ptr<Params> Params::Create(const base::ListValue& args, base::string16* error) {
DCHECK(error);
if (args.GetSize() != 1) {
if (args.GetSize() != 1) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("expected 1 arguments, got " + base::IntToString(args.GetSize())));
return nullptr;
return nullptr;
}
}
std::unique_ptr<Params> params(new Params());
std::unique_ptr<Params> params(new Params());
const base::Value* page_patterns_value = NULL;
const base::Value* page_patterns_value = NULL;
if (args.Get(0, &page_patterns_value) &&
if (args.Get(0, &page_patterns_value) &&
!page_patterns_value->is_none()) {
!page_patterns_value->is_none()) {
{
{
const base::ListValue* list = NULL;
const base::ListValue* list = NULL;
if (!page_patterns_value->GetAsList(&list)) {
if (!page_patterns_value->GetAsList(&list)) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'page_patterns': expected list, got " + std::string(base::Value::GetTypeName(page_patterns_value->type()))));
return std::unique_ptr<Params>();
return std::unique_ptr<Params>();
}
}
else {
else {
if (!json_schema_compiler::util::PopulateArrayFromList(*list, &params->page_patterns)) {
if (!json_schema_compiler::util::PopulateArrayFromList(*list, &params->page_patterns, error)) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("unable to populate array 'addAllowedPages'"));
return std::unique_ptr<Params>();
return std::unique_ptr<Params>();
}
}
}
}
}
}
}
}
else {
else {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("'page_patterns' is required"));
return std::unique_ptr<Params>();
return std::unique_ptr<Params>();
}
}
return params;
return params;
}
}
std::unique_ptr<base::ListValue> Results::Create() {
std::unique_ptr<base::ListValue> Results::Create() {
std::unique_ptr<base::ListValue> create_results(new base::ListValue());
std::unique_ptr<base::ListValue> create_results(new base::ListValue());
return create_results;
return create_results;
}
}
} // namespace AddAllowedPages
} // namespace AddAllowedPages
namespace RemoveAllowedPages {
namespace RemoveAllowedPages {
Params::Params() {}
Params::Params() {}
Params::~Params() {}
Params::~Params() {}
// static
// static
std::unique_ptr<Params> Params::Create(const base::ListValue& args) {
std::unique_ptr<Params> Params::Create(const base::ListValue& args, base::string16* error) {
DCHECK(error);
if (args.GetSize() != 1) {
if (args.GetSize() != 1) {
if (error->length())
error->append(UTF8ToUTF16("; "));
error->append(UTF8ToUTF16("expected 1 arguments, got " + base::IntToString(args.GetSize())));
return nullptr;
return nullptr;
}
}
std::unique_ptr<Params> params(new Params());
std::unique_ptr<Params> params(new Params());
const base::Value* page_patterns_value = NULL;
const base::Value* page_patterns_value = NULL;
if (args.Get(0, &page_patterns_value) &&
if (args.Get(0, &page_patterns_value) &&
!page_patterns_value->is_none()) {
!page_patterns_value->is_none()) {
{
{
const base::ListValue* list = NULL;
const base
if (!page_patterns_value->GetAsList(&list)) {
return std::unique_ptr<Params>();
}
else {
if (!json_schema_compiler::util::PopulateArrayFromList(*list, &params->page_patterns)) {
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 RemoveAllowedPages
namespace GetAllowedPages {
std::unique_ptr<base::ListValue> Results::Create(const std::vector<std::string>& result) {
std::unique_ptr<base::ListValue> create_results(new base::ListValue());
create_results->Append(json_schema_compiler::util::CreateValueFromArray(result));
return create_results;
}
} // namespace GetAllowedPages
} // namespace declarative_net_request
} // namespace api
} // namespace extensions

Diferencias guardadas