OLD | NEW |
(Empty) | |
| 1 // Copyright 2017 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/common/api/declarative_net_request/ruleset_indexer.h" |
| 6 |
| 7 #include <algorithm> |
| 8 |
| 9 #include "base/numerics/safe_conversions.h" |
| 10 #include "components/subresource_filter/core/common/flat/url_pattern_index_gener
ated.h" |
| 11 #include "extensions/common/api/declarative_net_request.h" |
| 12 #include "extensions/common/api/declarative_net_request/constants.h" |
| 13 #include "extensions/common/api/declarative_net_request/indexed_rule.h" |
| 14 |
| 15 namespace extensions { |
| 16 namespace declarative_net_request { |
| 17 |
| 18 namespace { |
| 19 using UrlRule = ::subresource_filter::flat::UrlRule; |
| 20 using UrlRuleOffset = ::flatbuffers::Offset<UrlRule>; |
| 21 using FlatStringOffset = ::flatbuffers::Offset<flatbuffers::String>; |
| 22 using FlatStringListOffset = |
| 23 ::flatbuffers::Offset<flatbuffers::Vector<FlatStringOffset>>; |
| 24 |
| 25 FlatStringListOffset CreateVectorOfSharedStrings( |
| 26 flatbuffers::FlatBufferBuilder* builder_, |
| 27 const std::vector<std::string>& vec) { |
| 28 std::vector<FlatStringOffset> offsets(vec.size()); |
| 29 for (size_t i = 0; i < vec.size(); i++) |
| 30 offsets[i] = builder_->CreateSharedString(vec[i]); |
| 31 return builder_->CreateVector(offsets); |
| 32 } |
| 33 |
| 34 api::declarative_net_request::RuleActionType GetRuleActionType( |
| 35 const IndexedRule& indexed_rule) { |
| 36 if (indexed_rule.options & OptionFlag::OptionFlag_IS_WHITELIST) |
| 37 return api::declarative_net_request::RULE_ACTION_TYPE_WHITELIST; |
| 38 if (!indexed_rule.redirect_url.empty()) |
| 39 return api::declarative_net_request::RULE_ACTION_TYPE_REDIRECT; |
| 40 return api::declarative_net_request::RULE_ACTION_TYPE_BLOCK; |
| 41 } |
| 42 |
| 43 // std::string string_to_hex(const std::string& input) |
| 44 // { |
| 45 // static const char* const lut = "0123456789ABCDEF"; |
| 46 // size_t len = input.length(); |
| 47 |
| 48 // std::string output; |
| 49 // output.reserve(2 * len); |
| 50 // for (size_t i = 0; i < len; ++i) |
| 51 // { |
| 52 // const unsigned char c = input[i]; |
| 53 // output.push_back(lut[c >> 4]); |
| 54 // output.push_back(lut[c & 15]); |
| 55 // } |
| 56 // return output; |
| 57 // } |
| 58 } |
| 59 |
| 60 RulesetIndexer::RulesetIndexer() |
| 61 : blacklist_index_builder_(&builder_), |
| 62 whitelist_index_builder_(&builder_), |
| 63 redirect_index_builder_(&builder_), |
| 64 finished_(false) {} |
| 65 |
| 66 RulesetIndexer::~RulesetIndexer() = default; |
| 67 |
| 68 ParseResult RulesetIndexer::AddUrlRule(const IndexedRule& indexed_rule) { |
| 69 cnt_++; |
| 70 DCHECK(std::is_sorted(indexed_rule.domains_included.begin(), |
| 71 indexed_rule.domains_included.end())); |
| 72 DCHECK(std::is_sorted(indexed_rule.domains_excluded.begin(), |
| 73 indexed_rule.domains_excluded.end())); |
| 74 DCHECK_NE(UrlPatternType::UrlPatternType_REGEXP, |
| 75 indexed_rule.url_pattern_type); |
| 76 DCHECK(!(indexed_rule.element_types & |
| 77 (ElementType::ElementType_OBJECT_SUBREQUEST | |
| 78 ElementType::ElementType_POPUP))); |
| 79 |
| 80 auto domains_included_offset = |
| 81 CreateVectorOfSharedStrings(&builder_, indexed_rule.domains_included); |
| 82 auto domains_excluded_offset = |
| 83 CreateVectorOfSharedStrings(&builder_, indexed_rule.domains_excluded); |
| 84 auto url_pattern_offset = |
| 85 builder_.CreateSharedString(indexed_rule.url_pattern); |
| 86 UrlRuleOffset offset = subresource_filter::flat::CreateUrlRule( |
| 87 builder_, indexed_rule.options, indexed_rule.element_types, |
| 88 indexed_rule.activation_types, indexed_rule.url_pattern_type, |
| 89 indexed_rule.anchor_left, indexed_rule.anchor_right, |
| 90 domains_included_offset, domains_excluded_offset, url_pattern_offset, |
| 91 indexed_rule.id, indexed_rule.priority); |
| 92 const api::declarative_net_request::RuleActionType type = |
| 93 GetRuleActionType(indexed_rule); |
| 94 GetBuilder(type)->IndexUrlRule(offset); |
| 95 |
| 96 if (type == api::declarative_net_request::RULE_ACTION_TYPE_REDIRECT) { |
| 97 DCHECK(!indexed_rule.redirect_url.empty()); |
| 98 auto redirect_url_offset = |
| 99 builder_.CreateSharedString(indexed_rule.redirect_url); |
| 100 metadata_.push_back(flat::CreateExtensionRuleMetadata( |
| 101 builder_, indexed_rule.id, redirect_url_offset)); |
| 102 } |
| 103 return ParseResult::SUCCESS; |
| 104 } |
| 105 |
| 106 RulesetIndexer::SerializedData RulesetIndexer::FinishAndGetData() { |
| 107 if (!finished_) { |
| 108 finished_ = true; |
| 109 auto blacklist_index_offset = blacklist_index_builder_.Finish(); |
| 110 auto whitelist_index_offset = whitelist_index_builder_.Finish(); |
| 111 auto redirect_index_offset = redirect_index_builder_.Finish(); |
| 112 // TODO why does this take a pointer? |
| 113 auto extension_metadata_offset = |
| 114 builder_.CreateVectorOfSortedTables(&metadata_); |
| 115 |
| 116 auto root_offset = flat::CreateExtensionIndexedRuleset( |
| 117 builder_, blacklist_index_offset, whitelist_index_offset, |
| 118 redirect_index_offset, extension_metadata_offset); |
| 119 flat::FinishExtensionIndexedRulesetBuffer(builder_, root_offset); |
| 120 } |
| 121 LOG(ERROR) << "--------cnt_ " << cnt_ << "\n"; |
| 122 return SerializedData(builder_.GetBufferPointer(), |
| 123 base::strict_cast<size_t>(builder_.GetSize())); |
| 124 } |
| 125 |
| 126 RulesetIndexer::UrlPatternIndexBuilder* RulesetIndexer::GetBuilder( |
| 127 api::declarative_net_request::RuleActionType type) { |
| 128 switch (type) { |
| 129 case api::declarative_net_request::RULE_ACTION_TYPE_BLOCK: |
| 130 return &blacklist_index_builder_; |
| 131 case api::declarative_net_request::RULE_ACTION_TYPE_WHITELIST: |
| 132 return &whitelist_index_builder_; |
| 133 case api::declarative_net_request::RULE_ACTION_TYPE_REDIRECT: |
| 134 return &redirect_index_builder_; |
| 135 case api::declarative_net_request::RULE_ACTION_TYPE_NONE: |
| 136 NOTREACHED(); |
| 137 } |
| 138 return nullptr; |
| 139 } |
| 140 |
| 141 bool VerifyRuleset(const RulesetIndexer::SerializedData& data) { |
| 142 flatbuffers::Verifier verifier(data.first, data.second); |
| 143 return flat::VerifyExtensionIndexedRulesetBuffer(verifier); |
| 144 } |
| 145 |
| 146 } // namespace declarative_net_request |
| 147 } // namespace extensions |
OLD | NEW |