DNR Prototype: With flatbuffers

extensions/common/api/declarative_net_request/ruleset_indexer.cc

Index: extensions/common/api/declarative_net_request/ruleset_indexer.cc
diff --git a/extensions/common/api/declarative_net_request/ruleset_indexer.cc b/extensions/common/api/declarative_net_request/ruleset_indexer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c1a6e1e9571a9e7330eb5af1a21fe84a61987936
--- /dev/null
+++ b/extensions/common/api/declarative_net_request/ruleset_indexer.cc
@@ -0,0 +1,147 @@
+// Copyright 2017 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.
+
+#include "extensions/common/api/declarative_net_request/ruleset_indexer.h"
+
+#include <algorithm>
+
+#include "base/numerics/safe_conversions.h"
+#include "components/subresource_filter/core/common/flat/url_pattern_index_generated.h"
+#include "extensions/common/api/declarative_net_request.h"
+#include "extensions/common/api/declarative_net_request/constants.h"
+#include "extensions/common/api/declarative_net_request/indexed_rule.h"
+
+namespace extensions {
+namespace declarative_net_request {
+
+namespace {
+using UrlRule = ::subresource_filter::flat::UrlRule;
+using UrlRuleOffset = ::flatbuffers::Offset<UrlRule>;
+using FlatStringOffset = ::flatbuffers::Offset<flatbuffers::String>;
+using FlatStringListOffset =
+    ::flatbuffers::Offset<flatbuffers::Vector<FlatStringOffset>>;
+
+FlatStringListOffset CreateVectorOfSharedStrings(
+    flatbuffers::FlatBufferBuilder* builder_,
+    const std::vector<std::string>& vec) {
+  std::vector<FlatStringOffset> offsets(vec.size());
+  for (size_t i = 0; i < vec.size(); i++)
+    offsets[i] = builder_->CreateSharedString(vec[i]);
+  return builder_->CreateVector(offsets);
+}
+
+api::declarative_net_request::RuleActionType GetRuleActionType(
+    const IndexedRule& indexed_rule) {
+  if (indexed_rule.options & OptionFlag::OptionFlag_IS_WHITELIST)
+    return api::declarative_net_request::RULE_ACTION_TYPE_WHITELIST;
+  if (!indexed_rule.redirect_url.empty())
+    return api::declarative_net_request::RULE_ACTION_TYPE_REDIRECT;
+  return api::declarative_net_request::RULE_ACTION_TYPE_BLOCK;
+}
+
+// std::string string_to_hex(const std::string& input)
+// {
+//     static const char* const lut = "0123456789ABCDEF";
+//     size_t len = input.length();
+
+//     std::string output;
+//     output.reserve(2 * len);
+//     for (size_t i = 0; i < len; ++i)
+//     {
+//         const unsigned char c = input[i];
+//         output.push_back(lut[c >> 4]);
+//         output.push_back(lut[c & 15]);
+//     }
+//     return output;
+// }
+}
+
+RulesetIndexer::RulesetIndexer()
+    : blacklist_index_builder_(&builder_),
+      whitelist_index_builder_(&builder_),
+      redirect_index_builder_(&builder_),
+      finished_(false) {}
+
+RulesetIndexer::~RulesetIndexer() = default;
+
+ParseResult RulesetIndexer::AddUrlRule(const IndexedRule& indexed_rule) {
+  cnt_++;
+  DCHECK(std::is_sorted(indexed_rule.domains_included.begin(),
+                        indexed_rule.domains_included.end()));
+  DCHECK(std::is_sorted(indexed_rule.domains_excluded.begin(),
+                        indexed_rule.domains_excluded.end()));
+  DCHECK_NE(UrlPatternType::UrlPatternType_REGEXP,
+            indexed_rule.url_pattern_type);
+  DCHECK(!(indexed_rule.element_types &
+           (ElementType::ElementType_OBJECT_SUBREQUEST |
+            ElementType::ElementType_POPUP)));
+
+  auto domains_included_offset =
+      CreateVectorOfSharedStrings(&builder_, indexed_rule.domains_included);
+  auto domains_excluded_offset =
+      CreateVectorOfSharedStrings(&builder_, indexed_rule.domains_excluded);
+  auto url_pattern_offset =
+      builder_.CreateSharedString(indexed_rule.url_pattern);
+  UrlRuleOffset offset = subresource_filter::flat::CreateUrlRule(
+      builder_, indexed_rule.options, indexed_rule.element_types,
+      indexed_rule.activation_types, indexed_rule.url_pattern_type,
+      indexed_rule.anchor_left, indexed_rule.anchor_right,
+      domains_included_offset, domains_excluded_offset, url_pattern_offset,
+      indexed_rule.id, indexed_rule.priority);
+  const api::declarative_net_request::RuleActionType type =
+      GetRuleActionType(indexed_rule);
+  GetBuilder(type)->IndexUrlRule(offset);
+
+  if (type == api::declarative_net_request::RULE_ACTION_TYPE_REDIRECT) {
+    DCHECK(!indexed_rule.redirect_url.empty());
+    auto redirect_url_offset =
+        builder_.CreateSharedString(indexed_rule.redirect_url);
+    metadata_.push_back(flat::CreateExtensionRuleMetadata(
+        builder_, indexed_rule.id, redirect_url_offset));
+  }
+  return ParseResult::SUCCESS;
+}
+
+RulesetIndexer::SerializedData RulesetIndexer::FinishAndGetData() {
+  if (!finished_) {
+    finished_ = true;
+    auto blacklist_index_offset = blacklist_index_builder_.Finish();
+    auto whitelist_index_offset = whitelist_index_builder_.Finish();
+    auto redirect_index_offset = redirect_index_builder_.Finish();
+    // TODO why does this take a pointer?
+    auto extension_metadata_offset =
+        builder_.CreateVectorOfSortedTables(&metadata_);
+
+    auto root_offset = flat::CreateExtensionIndexedRuleset(
+        builder_, blacklist_index_offset, whitelist_index_offset,
+        redirect_index_offset, extension_metadata_offset);
+    flat::FinishExtensionIndexedRulesetBuffer(builder_, root_offset);
+  }
+  LOG(ERROR) << "--------cnt_ " << cnt_ << "\n";
+  return SerializedData(builder_.GetBufferPointer(),
+                        base::strict_cast<size_t>(builder_.GetSize()));
+}
+
+RulesetIndexer::UrlPatternIndexBuilder* RulesetIndexer::GetBuilder(
+    api::declarative_net_request::RuleActionType type) {
+  switch (type) {
+    case api::declarative_net_request::RULE_ACTION_TYPE_BLOCK:
+      return &blacklist_index_builder_;
+    case api::declarative_net_request::RULE_ACTION_TYPE_WHITELIST:
+      return &whitelist_index_builder_;
+    case api::declarative_net_request::RULE_ACTION_TYPE_REDIRECT:
+      return &redirect_index_builder_;
+    case api::declarative_net_request::RULE_ACTION_TYPE_NONE:
+      NOTREACHED();
+  }
+  return nullptr;
+}
+
+bool VerifyRuleset(const RulesetIndexer::SerializedData& data) {
+  flatbuffers::Verifier verifier(data.first, data.second);
+  return flat::VerifyExtensionIndexedRulesetBuffer(verifier);
+}
+
+}  // namespace declarative_net_request
+}  // namespace extensions