DNR Prototype: With flatbuffers

components/subresource_filter/core/common/url_pattern_index.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 "components/subresource_filter/core/common/url_pattern_index.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "components/subresource_filter/core/common/ngram_extractor.h"
 #include "components/subresource_filter/core/common/url_pattern.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 namespace subresource_filter {
 
 namespace {
 
 using FlatStringOffset = flatbuffers::Offset<flatbuffers::String>;
 using FlatDomains = flatbuffers::Vector<FlatStringOffset>;
 using FlatDomainsOffset = flatbuffers::Offset<FlatDomains>;
+using ActivationMaskPair =
+    std::pair<proto::ActivationType, flat::ActivationType>;
+using ElementTypeMaskPair = std::pair<proto::ElementType, flat::ElementType>;
+
+const ActivationMaskPair kActivationMaskPairs[] = {
+    {proto::ACTIVATION_TYPE_DOCUMENT, flat::ActivationType_DOCUMENT},
+    {proto::ACTIVATION_TYPE_ELEMHIDE,
+     flat::ActivationType_NONE},  // ELEMHIDE is not supported.
+    {proto::ACTIVATION_TYPE_GENERICHIDE,
+     flat::ActivationType_NONE},  // Generic block is not supported.
+    {proto::ACTIVATION_TYPE_GENERICBLOCK, flat::ActivationType_GENERIC_BLOCK},
+};
+
+const ElementTypeMaskPair kElementTypeMaskPairs[] = {
+    {proto::ELEMENT_TYPE_OTHER, flat::ElementType_OTHER},
+    {proto::ELEMENT_TYPE_SCRIPT, flat::ElementType_SCRIPT},
+    {proto::ELEMENT_TYPE_IMAGE, flat::ElementType_IMAGE},
+    {proto::ELEMENT_TYPE_STYLESHEET, flat::ElementType_STYLESHEET},
+    {proto::ELEMENT_TYPE_OBJECT, flat::ElementType_OBJECT},
+    {proto::ELEMENT_TYPE_XMLHTTPREQUEST, flat::ElementType_XMLHTTPREQUEST},
+    {proto::ELEMENT_TYPE_OBJECT_SUBREQUEST,
+     flat::ElementType_OBJECT},  // Normally we can not distinguish between the
+                                 // main plugin resource and any other loads it
+                                 // makes. We treat them both as OBJECT
+                                 // requests.
+    {proto::ELEMENT_TYPE_SUBDOCUMENT, flat::ElementType_SUBDOCUMENT},
+    {proto::ELEMENT_TYPE_PING, flat::ElementType_PING},
+    {proto::ELEMENT_TYPE_MEDIA, flat::ElementType_MEDIA},
+    {proto::ELEMENT_TYPE_FONT, flat::ElementType_FONT},
+    {proto::ELEMENT_TYPE_POPUP,
+     flat::ElementType_NONE},  // Filterning popups is not supported.
+    {proto::ELEMENT_TYPE_WEBSOCKET, flat::ElementType_WEBSOCKET},
+};
 
 base::StringPiece ToStringPiece(const flatbuffers::String* string) {
   DCHECK(string);
   return base::StringPiece(string->c_str(), string->size());
 }
 
 // Performs three-way comparison between two domains. In the total order defined
 // by this predicate, the lengths of domains will be monotonically decreasing.
 int CompareDomains(base::StringPiece lhs_domain, base::StringPiece rhs_domain) {
   if (lhs_domain.size() != rhs_domain.size())
@@ skipping 98 matching lines @@
       case proto::ANCHOR_TYPE_SUBDOMAIN:
         *result = flat::AnchorType_SUBDOMAIN;
         break;
       default:
         return false;  // Unsupported anchor type.
     }
     return true;
   }
 
   bool InitializeOptions() {
+    static_assert(flat::OptionFlag_ANY <= std::numeric_limits<uint8_t>::max(),
+                  "Option flags can not be stored in uint8_t.");
+
     if (rule_.semantics() == proto::RULE_SEMANTICS_WHITELIST) {
       options_ |= flat::OptionFlag_IS_WHITELIST;
     } else if (rule_.semantics() != proto::RULE_SEMANTICS_BLACKLIST) {
       return false;  // Unsupported semantics.
     }
 
     switch (rule_.source_type()) {
       case proto::SOURCE_TYPE_ANY:
         options_ |= flat::OptionFlag_APPLIES_TO_THIRD_PARTY;
       // Note: fall through here intentionally.
       case proto::SOURCE_TYPE_FIRST_PARTY:
         options_ |= flat::OptionFlag_APPLIES_TO_FIRST_PARTY;
         break;
       case proto::SOURCE_TYPE_THIRD_PARTY:
         options_ |= flat::OptionFlag_APPLIES_TO_THIRD_PARTY;
         break;
 
       default:
         return false;  // Unsupported source type.
     }
 
     if (rule_.match_case())
       options_ |= flat::OptionFlag_IS_MATCH_CASE;
 
     return true;
   }
 
   bool InitializeElementTypes() {
-    static_assert(
-        proto::ELEMENT_TYPE_ALL <= std::numeric_limits<uint16_t>::max(),
-        "Element types can not be stored in uint16_t.");
-    element_types_ = static_cast<uint16_t>(rule_.element_types());
+    static_assert(flat::ElementType_ANY <= std::numeric_limits<uint16_t>::max(),
+                  "Element types can not be stored in uint16_t.");
 
-    // Note: Normally we can not distinguish between the main plugin resource
-    // and any other loads it makes. We treat them both as OBJECT requests.
-    if (element_types_ & proto::ELEMENT_TYPE_OBJECT_SUBREQUEST)
-      element_types_ |= proto::ELEMENT_TYPE_OBJECT;
+    element_types_ = flat::ElementType_NONE;
 
-    // Ignore unknown element types.
-    element_types_ &= proto::ELEMENT_TYPE_ALL;
-    // Filtering popups is not supported.
-    element_types_ &= ~proto::ELEMENT_TYPE_POPUP;
+    for (const auto& pair : kElementTypeMaskPairs)
+      if (rule_.element_types() & pair.first)
+        element_types_ |= pair.second;
 
     return true;
   }
 
   bool InitializeActivationTypes() {
     static_assert(
-        proto::ACTIVATION_TYPE_ALL <= std::numeric_limits<uint8_t>::max(),
+        flat::ActivationType_ANY <= std::numeric_limits<uint8_t>::max(),
         "Activation types can not be stored in uint8_t.");
-    activation_types_ = static_cast<uint8_t>(rule_.activation_types());
+    activation_types_ = flat::ActivationType_NONE;
 
-    // Only the following activation types are supported, ignore the others.
-    activation_types_ &=
-        proto::ACTIVATION_TYPE_DOCUMENT | proto::ACTIVATION_TYPE_GENERICBLOCK;
+    for (const auto& pair : kActivationMaskPairs)
+      if (rule_.activation_types() & pair.first)
+        activation_types_ |= pair.second;
 
     return true;
   }
 
   bool InitializeUrlPattern() {
     switch (rule_.url_pattern_type()) {
       case proto::URL_PATTERN_TYPE_SUBSTRING:
         url_pattern_type_ = flat::UrlPatternType_SUBSTRING;
         break;
       case proto::URL_PATTERN_TYPE_WILDCARDED:
@@ skipping 190 matching lines @@
 // the |origin|. Thus, domain filters with more domain components trump filters
 // with fewer domain components, i.e. the more specific a filter is, the higher
 // the priority.
 //
 // A rule whose domain list is empty or contains only negative domains is still
 // considered a "generic" rule. Therefore, if |disable_generic_rules| is set,
 // this function will always return false for such rules.
 bool DoesOriginMatchDomainList(const url::Origin& origin,
                                const flat::UrlRule& rule,
                                bool disable_generic_rules) {
-  const bool is_generic = !rule.domains_included();
-  DCHECK(is_generic || rule.domains_included()->size());
+  const bool is_generic =
+      !rule.domains_included() || !rule.domains_included()->size();
+  // DCHECK(is_generic || rule.domains_included()->size());
   if (disable_generic_rules && is_generic)
     return false;
 
   // Unique |origin| matches lists of exception domains only.
   if (origin.unique())
     return is_generic;
 
   size_t longest_matching_included_domain_length = 1;
   if (!is_generic) {
     longest_matching_included_domain_length =
@@ skipping 136 matching lines @@
       (activation_type == proto::ACTIVATION_TYPE_UNSPECIFIED)) {
     return nullptr;
   }
 
   return FindMatchInFlatUrlPatternIndex(*flat_index_, url, first_party_origin,
                                         element_type, activation_type,
                                         is_third_party, disable_generic_rules);
 }
 
 }  // namespace subresource_filter