DNR Prototype: With flatbuffers

extensions/common/api/declarative_net_request/indexed_rule.cc

+// 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/indexed_rule.h"
+
+#include <set>
+#include <utility>
+
+#include "base/numerics/safe_conversions.h"
+#include "base/stl_util.h"
+#include "extensions/common/api/declarative_net_request/constants.h"
+
+namespace extensions {
+namespace declarative_net_request {
+
+namespace {
+
+class UrlFilterParser {
+ public:
+  UrlFilterParser(std::string url_filter, IndexedRule* indexed_rule)
+      : url_filter_(std::move(url_filter)),
+        url_filter_len_(url_filter_.length()),
+        index_(0),
+        result_(ParseResult::SUCCESS),
+        indexed_rule_(indexed_rule) {
+    DCHECK_NE(0u, url_filter_len_);
+  }
+
+  ParseResult Parse() {
+    DCHECK_EQ(0u, index_);
+    DCHECK_EQ(ParseResult::SUCCESS, result_);
+
+    ParseLeftAnchor();
+    DCHECK(result_ != ParseResult::SUCCESS || index_ <= 2u);
+
+    ParseFilterString();
+    DCHECK(result_ != ParseResult::SUCCESS || index_ == url_filter_len_ ||
+           index_ + 1 == url_filter_len_);
+
+    ParseRightAnchor();
+    DCHECK(result_ != ParseResult::SUCCESS || index_ == url_filter_len_);
+
+    return result_;
+  }
+
+  void ParseLeftAnchor() {
+    DCHECK_EQ(0u, index_);
+    DCHECK_EQ(ParseResult::SUCCESS, result_);
+
+    indexed_rule_->anchor_left = AnchorType::AnchorType_NONE;
+
+    if (IsAtAnchor()) {
+      index_++;
+      indexed_rule_->anchor_left = AnchorType::AnchorType_BOUNDARY;
+      if (IsAtAnchor()) {
+        index_++;
+        indexed_rule_->anchor_left = AnchorType::AnchorType_SUBDOMAIN;
+      }
+    }
+  }
+
+  void ParseFilterString() {
+    if (result_ != ParseResult::SUCCESS)
+      return;
+
+    indexed_rule_->url_pattern_type = UrlPatternType::UrlPatternType_SUBSTRING;
+    int left_index = index_;
+    while (index_ < url_filter_len_) {
+      if (IsAtRightAnchor())
+        break;
+      if (IsAtSeparatorOrWildcard())
+        indexed_rule_->url_pattern_type =
+            UrlPatternType::UrlPatternType_WILDCARDED;
+      index_++;
+    }
+    // Note empty url patterns need to be supported.
+    indexed_rule_->url_pattern =
+        url_filter_.substr(left_index, index_ - left_index);
+  }
+
+  void ParseRightAnchor() {
+    if (result_ != ParseResult::SUCCESS)
+      return;
+    indexed_rule_->anchor_right = AnchorType::AnchorType_NONE;
+    if (IsAtRightAnchor()) {
+      index_++;
+      indexed_rule_->anchor_right = AnchorType::AnchorType_BOUNDARY;
+    }
+  }
+
+ private:
+  bool IsAtSeparatorOrWildcard() const {
+    return IsAtValidIndex() && (url_filter_[index_] == kSeparatorCharacter ||
+                                url_filter_[index_] == kWildcardCharacter);
+  }
+
+  bool IsAtRightAnchor() const {
+    return IsAtAnchor() && index_ > 0 && index_ + 1 == url_filter_len_;
+  }
+
+  bool IsAtValidIndex() const { return index_ < url_filter_len_; }
+
+  bool IsAtAnchor() const {
+    return IsAtValidIndex() && url_filter_[index_] == kAnchorCharacter;
+  }
+
+  static constexpr char kAnchorCharacter = '|';
+  static constexpr char kSeparatorCharacter = '^';
+  static constexpr char kWildcardCharacter = '*';
+
+  const std::string url_filter_;
+  const size_t url_filter_len_;
+  size_t index_;
+  ParseResult result_;
+  IndexedRule* indexed_rule_;  // Weak.
+};
+
+uint8_t GetOptionsMask(const Rule& parsed_rule) {
+  uint8_t mask = OptionFlag::OptionFlag_NONE;
+  if (parsed_rule.action.type ==
+      api::declarative_net_request::RULE_ACTION_TYPE_WHITELIST)
+    mask |= OptionFlag::OptionFlag_IS_WHITELIST;
+  if (parsed_rule.condition.url_filter_is_case_sensitive &&
+      *parsed_rule.condition.url_filter_is_case_sensitive)
+    mask |= OptionFlag::OptionFlag_IS_MATCH_CASE;
+
+  switch (parsed_rule.condition.domain_type) {
+    case api::declarative_net_request::DOMAIN_TYPE_FIRST_PARTY:
+      mask |= OptionFlag::OptionFlag_APPLIES_TO_FIRST_PARTY;
+      break;
+    case api::declarative_net_request::DOMAIN_TYPE_THIRD_PARTY:
+      mask |= OptionFlag::OptionFlag_APPLIES_TO_THIRD_PARTY;
+      break;
+    case api::declarative_net_request::DOMAIN_TYPE_ANY:
+    case api::declarative_net_request::DOMAIN_TYPE_NONE:
+      mask |= (OptionFlag::OptionFlag_APPLIES_TO_FIRST_PARTY |
+               OptionFlag::OptionFlag_APPLIES_TO_THIRD_PARTY);
+      break;
+  }
+  return mask;
+}
+
+uint8_t GetActivationTypes(const Rule& parsed_rule) {
+  // Extensions don't use any activation types.
+  return ActivationType::ActivationType_NONE;
+}
+
+ElementType GetElementType(
+    api::declarative_net_request::ResourceType resource_type) {
+  switch (resource_type) {
+    case api::declarative_net_request::RESOURCE_TYPE_NONE:
+      return ElementType::ElementType_NONE;
+    case api::declarative_net_request::RESOURCE_TYPE_SUB_FRAME:
+      return ElementType::ElementType_SUBDOCUMENT;
+    case api::declarative_net_request::RESOURCE_TYPE_STYLESHEET:
+      return ElementType::ElementType_STYLESHEET;
+    case api::declarative_net_request::RESOURCE_TYPE_SCRIPT:
+      return ElementType::ElementType_SCRIPT;
+    case api::declarative_net_request::RESOURCE_TYPE_IMAGE:
+      return ElementType::ElementType_IMAGE;
+    case api::declarative_net_request::RESOURCE_TYPE_FONT:
+      return ElementType::ElementType_FONT;
+    case api::declarative_net_request::RESOURCE_TYPE_OBJECT:
+      return ElementType::ElementType_OBJECT;
+    case api::declarative_net_request::RESOURCE_TYPE_XMLHTTPREQUEST:
+      return ElementType::ElementType_XMLHTTPREQUEST;
+    case api::declarative_net_request::RESOURCE_TYPE_PING:
+      return ElementType::ElementType_PING;
+    case api::declarative_net_request::RESOURCE_TYPE_MEDIA:
+      return ElementType::ElementType_MEDIA;
+    case api::declarative_net_request::RESOURCE_TYPE_WEBSOCKET:
+      return ElementType::ElementType_WEBSOCKET;
+    case api::declarative_net_request::RESOURCE_TYPE_OTHER:
+      return ElementType::ElementType_OTHER;
+  }
+  NOTREACHED();
+  return ElementType::ElementType_NONE;
+}
+
+uint16_t GetResourceTypesMask(
+    const std::vector<api::declarative_net_request::ResourceType>*
+        resource_types) {
+  if (!resource_types)
+    return ElementType::ElementType_NONE;
+
+  uint16_t mask = ElementType::ElementType_NONE;
+  for (const auto resource_type : *resource_types)
+    mask |= GetElementType(resource_type);
+  DCHECK(!(mask & (ElementType::ElementType_OBJECT_SUBREQUEST |
+                   ElementType::ElementType_POPUP)));
+  return mask;
+}
+
+ParseResult ComputeElementTypes(const Rule& rule, uint16_t* element_types) {
+  uint16_t include_element_type_mask =
+      GetResourceTypesMask(rule.condition.resource_types.get());
+  uint16_t exclude_element_type_mask =
+      GetResourceTypesMask(rule.condition.exclude_resource_types.get());
+  exclude_element_type_mask |= (ElementType::ElementType_POPUP |
+                                ElementType::ElementType_OBJECT_SUBREQUEST);
+  if (include_element_type_mask & exclude_element_type_mask)
+    return ParseResult::ERROR_RESOURCE_TYPE_DUPLICATED;
+  *element_types = (include_element_type_mask ? include_element_type_mask
+                                              : ElementType::ElementType_ANY) &
+                   (~exclude_element_type_mask);
+  return ParseResult::SUCCESS;
+}
+
+std::vector<std::string> GetSortedAndUniqueDomains(
+    std::unique_ptr<std::vector<std::string>> domains) {
+  std::vector<std::string> result;
+  if (!domains)
+    return result;
+  // TODO is std::move necessary already rvalue.
+  result = std::move(*domains.release());
+  std::sort(result.begin(), result.end());
+  result.erase(std::unique(result.begin(), result.end()), result.end());
+  return result;
+}
+
+}  // namespace
+
+IndexedRule::IndexedRule() = default;
+IndexedRule::~IndexedRule() = default;
+
+ParseResult CreateIndexedRule(std::unique_ptr<Rule> parsed_rule,
+                              IndexedRule* indexed_rule) {
+  DCHECK(indexed_rule);
+
+  if (parsed_rule->id < kMinValidID)
+    return ParseResult::ERROR_INVALID_RULE_ID;
+
+  const bool is_redirect_rule =
+      parsed_rule->action.type ==
+      api::declarative_net_request::RULE_ACTION_TYPE_REDIRECT;
+  if (is_redirect_rule && (!parsed_rule->action.redirect_url ||
+                           parsed_rule->action.redirect_url->empty()))
+    return ParseResult::ERROR_EMPTY_REDIRECT_URL;
+  if (is_redirect_rule && !parsed_rule->priority)
+    return ParseResult::ERROR_EMPTY_REDIRECT_RULE_PRIORITY;
+  if (is_redirect_rule && *parsed_rule->priority < kMinValidPriority)
+    return ParseResult::ERROR_INVALID_REDIRECT_RULE_PRIORITY;
+
+  indexed_rule->id = base::checked_cast<uint32_t>(parsed_rule->id);
+  indexed_rule->priority = base::checked_cast<uint32_t>(
+      parsed_rule->priority ? *parsed_rule->priority : kDefaultPriority);
+  indexed_rule->options = GetOptionsMask(*parsed_rule);
+  indexed_rule->activation_types = GetActivationTypes(*parsed_rule);
+
+  // TODO is std::move needed here, already an rvalue.
+
+  indexed_rule->domains_included =
+      GetSortedAndUniqueDomains(std::move(parsed_rule->condition.domains));
+  indexed_rule->domains_excluded = GetSortedAndUniqueDomains(
+      std::move(parsed_rule->condition.excluded_domains));
+
+  ParseResult result =
+      ComputeElementTypes(*parsed_rule, &indexed_rule->element_types);
+  if (result != ParseResult::SUCCESS)
+    return result;
+
+  if (parsed_rule->condition.url_filter &&
+      !parsed_rule->condition.url_filter->empty()) {
+    UrlFilterParser parser(
+        std::move(*parsed_rule->condition.url_filter.release()), indexed_rule);
+    result = parser.Parse();
+    if (result != ParseResult::SUCCESS)
+      return result;
+  }
+
+  return ParseResult::SUCCESS;
+}
+
+}  // namespace extensions
+}  // namespace declarative_net_request