Issue 4125 - [emscripten] Convert filter classes to C++

compiled/Filter.cpp

-#include <emscripten/bind.h>
-#include <unordered_map>
-
 #include "Filter.h"
 #include "CommentFilter.h"
+#include "InvalidFilter.h"
 #include "RegExpFilter.h"
+#include "BlockingFilter.h"
+#include "WhitelistFilter.h"
+#include "ElemHideBase.h"
 #include "ElemHideFilter.h"
 #include "ElemHideException.h"
+#include "CSSPropertyFilter.h"
+#include "StringMap.h"
 
 namespace
 {
-  std::unordered_map<std::wstring,FilterPtr> knownFilters;
+  StringMap<Filter*> knownFilters(8192);
 
-  void trim_spaces(std::wstring& str)
+  void NormalizeWhitespace(DependentString& text)
   {
-    size_t pos;
+    String::size_type start = 0;
+    String::size_type end = text.length();
 
-    // Remove leading whitespace
-    pos = str.find_first_not_of(L' ');
-    if (pos > 0)
-      str.erase(0, pos);
+    // Remove leading spaces and special characters like line breaks
+    for (; start < end; start++)
+      if (text[start] > ' ')
+        break;
 
-    // Remove trailing whitespace
-    pos = str.find_last_not_of(L' ');
-    if (pos < str.length() - 1)
-      str.erase(pos + 1);
-  }
+    // Now look for invalid characters inside the string
+    String::size_type pos;
+    for (pos = start; pos < end; pos++)
+      if (text[pos] < ' ')
+        break;
 
-  void remove_spaces(std::wstring& str)
-  {
-    for (size_t i = 0, l = str.length(); i < l; ++i)
+    if (pos < end)
     {
-      if (str[i] == L' ')
+      // Found invalid characters, copy all the valid characters while skipping
+      // the invalid ones.
+      String::size_type delta = 1;
+      for (pos = pos + 1; pos < end; pos++)
       {
-        str.erase(i, 1);
-        --i;
-        --l;
+        if (text[pos] < ' ')
+          delta++;
+        else
+          text[pos - delta] = text[pos];
       }
+      end -= delta;
     }
+
+    // Remove trailing spaces
+    for (; end > 0; end--)
+      if (text[end - 1] != ' ')
+        break;
+
+    // Set new string boundaries
+    text.reset(text, start, end - start);
   }
 }
 
-Filter::Filter(const std::wstring& text)
+Filter::Filter(Type type, const String& text)
+    : mType(type), mText(text)
 {
-  this->text = text;
+  annotate_address(this, "Filter");
 }
 
-const std::wstring Filter::Serialize()
+Filter::~Filter()
 {
-  return (
-    L"[Filter]\n"
-    L"text=" + text + L"\n"
-  );
+  knownFilters.erase(mText);
 }
 
-FilterPtr Filter::FromText(const std::wstring& text)
+OwnedString Filter::Serialize() const
 {
-  auto it = knownFilters.find(text);
-  if (it != knownFilters.end())
-    return it->second;
-
-  FilterPtr filter = FilterPtr(CommentFilter::Create(text));
-  if (!filter)
-    filter.reset(ElemHideBase::Create(text));
-  if (!filter)
-    filter.reset(RegExpFilter::Create(text));
-  return knownFilters[text] = filter;
-}
-
-const std::wstring Filter::Normalize(const std::wstring& text)
-{
-  std::wstring result(text);
-
-  // Remove special characters like line breaks
-  for (size_t i = 0, l = result.length(); i < l; ++i)
-  {
-    if (result[i] < L' ')
-    {
-      result.erase(i, 1);
-      --i;
-      --l;
-    }
-  }
-
-  trim_spaces(result);
-
-  {
-    size_t domainsEnd;
-    size_t selectorStart;
-    Filter::Type type = ElemHideBase::Parse(result, &domainsEnd, &selectorStart);
-    if (type != Filter::Type::UNKNOWN)
-    {
-      std::wstring domains = result.substr(0, domainsEnd);
-      std::wstring selector = result.substr(selectorStart);
-      remove_spaces(domains);
-      trim_spaces(selector);
-      return domains + (
-        type == Filter::Type::ELEMHIDEEXCEPTION ? L"#@#" : L"##"
-      ) + selector;
-    }
-  }
-
-  if (CommentFilter::Parse(result) == Filter::Type::UNKNOWN)
-    remove_spaces(result);
+  OwnedString result(u"[Filter]\ntext="_str);
+  result.append(mText);
+  result.append(u'\n');
   return result;
 }
 
-EMSCRIPTEN_BINDINGS(filter)
+Filter* Filter::FromText(DependentString& text)
 {
-  using namespace emscripten;
-  enum_<Filter::Type>("FilterType")
-      .value("INVALID", Filter::Type::INVALID)
-      .value("COMMENT", Filter::Type::COMMENT)
-      .value("BLOCKING", Filter::Type::BLOCKING)
-      .value("WHITELIST", Filter::Type::WHITELIST)
-      .value("ELEMHIDE", Filter::Type::ELEMHIDE)
-      .value("ELEMHIDEEXCEPTION", Filter::Type::ELEMHIDEEXCEPTION)
-      .value("CSSPROPERTY", Filter::Type::CSSPROPERTY);
+  NormalizeWhitespace(text);
+  if (text.empty())
+    return nullptr;
 
-  class_<Filter>("Filter")
-      .property("text", &Filter::GetText)
-      .property("type", &Filter::GetType)
-      .function("serialize", &Filter::Serialize)
-      .class_function("fromText", &Filter::FromText)
-      .class_function("normalize", &Filter::Normalize)
-      .smart_ptr<FilterPtr>("shared_ptr");
+  // Parsing also normalizes the filter text, so it has to be done before the
+  // lookup in knownFilters.
+  union
+  {
+    RegExpFilterData regexp;
+    ElemHideData elemhide;
+  } data;
+  DependentString error;
+
+  Filter::Type type = CommentFilter::Parse(text);
+  if (type == Filter::Type::UNKNOWN)
+    type = ElemHideBase::Parse(text, data.elemhide);
+  if (type == Filter::Type::UNKNOWN)
+    type = RegExpFilter::Parse(text, error, data.regexp);
+
+  auto knownFilter = knownFilters.find(text);
+  if (knownFilter)
+  {
+    knownFilter->second->AddRef();
+    return knownFilter->second;
+  }
+
+  FilterPtr filter;
+  switch (type)
+  {
+    case Filter::Type::COMMENT:
+      filter = new CommentFilter(text);
+      break;
+    case Filter::Type::INVALID:
+      filter = new InvalidFilter(text, error);
+      break;
+    case Filter::Type::BLOCKING:
+      filter = new BlockingFilter(text, data.regexp);
+      break;
+    case Filter::Type::WHITELIST:
+      filter = new WhitelistFilter(text, data.regexp);
+      break;
+    case Filter::Type::ELEMHIDE:
+      filter = new ElemHideFilter(text, data.elemhide);
+      break;
+    case Filter::Type::ELEMHIDEEXCEPTION:
+      filter = new ElemHideException(text, data.elemhide);
+      break;
+    case Filter::Type::CSSPROPERTY:
+      filter = new CSSPropertyFilter(text, data.elemhide);
+      if (static_cast<CSSPropertyFilter*>(filter.get())->IsGeneric())
+        filter = new InvalidFilter(text, u"filter_cssproperty_nodomain"_str);
+      break;
+    default:
+      // This should never happen but just in case
+      return nullptr;
+  }
+
+  // This is a hack: we looked up the entry using text but create it using
+  // filter->mText. This works because both are equal at this point. However,
+  // text refers to a temporary buffer which will go away.
+  enter_context("Adding to known filters");
+  knownFilter.assign(filter->mText, filter.get());
+  exit_context();
+
+  return filter.release();
 }