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

compiled/ElemHideBase.cpp

 #include "ElemHideBase.h"
-#include "ElemHideFilter.h"
-#include "ElemHideException.h"
-#include "tools.h"
+#include "CSSPropertyFilter.h"
+#include "StringScanner.h"
 
-class Scanner
+namespace
 {
-private:
-  const std::u16string& str;
-  size_t pos;
-  size_t end;
-public:
-  Scanner(const std::u16string& str) : str(str), pos(0), end(str.length()) {}
+  void NormalizeWhitespace(DependentString& text, String::size_type& domainsEnd,
+      String::size_type& selectorStart)
+  {
+    // For element hiding filters we only want to remove spaces preceding the
+    // selector part. The positions we've determined already have to be adjusted
+    // accordingly.
 
-  bool done()
-  {
-    return pos >= end;
+    String::size_type delta = 0;
+    String::size_type len = text.length();
+
+    // The first character is guaranteed to be a non-space, the string has been
+    // trimmed earlier.
+    for (String::size_type pos = 1; pos < len; pos++)
+    {
+      if (pos == domainsEnd)
+        domainsEnd -= delta;
+
+      // Only spaces before selectorStart position should be removed.
+      if (pos < selectorStart && text[pos] == ' ')
+        delta++;
+      else
+        text[pos - delta] = text[pos];
+    }
+    selectorStart -= delta;
+
+    text.reset(text, 0, len - delta);
   }
-
-  size_t position()
-  {
-    return pos - 1;
-  }
-
-  char16_t next()
-  {
-    return done() ? u'\0' : str[pos++];
-  }
-};
-
-ElemHideBase::ElemHideBase(const std::u16string& text, size_t domainsEnd, size_t selectorStart)
-    : ActiveFilter(text)
-{
 }
 
-Filter::Type ElemHideBase::Parse(const std::u16string& text, size_t* domainsEnd, size_t* selectorStart)
+ElemHideBase::ElemHideBase(Type type, const String& text, const ElemHideBaseData& data)
+    : ActiveFilter(type, text, false), mData(data)
 {
-  Scanner scanner(text);
+  if (mData.HasDomains())
+    ParseDomains(mData.GetDomainsSource(mText), u',');
+}
+
+Filter::Type ElemHideBase::Parse(DependentString& text, ElemHideData& data)
+{
+  StringScanner scanner(text);
 
   // Domains part
-  loop:
+  bool seenSpaces = false;
   while (!scanner.done())
   {
-    char16_t next = scanner.next();
+    String::value_type next = scanner.next();
     if (next == u'#')
     {
-      *domainsEnd = scanner.position();
+      data.mDomainsEnd = scanner.position();
       break;
     }
 
     switch (next)
     {
       case u'/':
       case u'*':
       case u'|':
       case u'@':
       case u'"':
       case u'!':
         return Type::UNKNOWN;
+      case u' ':
+        seenSpaces = true;
+        break;
     }
   }
 
-  bool exception = false;
-  char16_t next = scanner.next();
-  if (next == u'@')
-  {
-    exception = true;
-    next = scanner.next();
-  }
+  seenSpaces |= scanner.skip(u' ');
+  bool exception = scanner.skipOne(u'@');
+  if (exception)
+    seenSpaces |= scanner.skip(u' ');
 
+  String::value_type next = scanner.next();
   if (next != u'#')
     return Type::UNKNOWN;
 
   // Selector part
 
   // Selector shouldn't be empty
+  seenSpaces |= scanner.skip(u' ');
   if (scanner.done())
     return Type::UNKNOWN;
 
-  *selectorStart = scanner.position() + 1;
+  data.mSelectorStart = scanner.position() + 1;
   while (!scanner.done())
   {
     switch (scanner.next())
     {
       case u'{':
       case u'}':
         return Type::UNKNOWN;
     }
   }
 
-  return exception ? Type::ELEMHIDEEXCEPTION : Type::ELEMHIDE;
+  // We are done validating, now we can normalize whitespace and the domain part
+  if (seenSpaces)
+    NormalizeWhitespace(text, data.mDomainsEnd, data.mSelectorStart);
+  DependentString(text, 0, data.mDomainsEnd).toLower();
+
+  if (exception)
+    return Type::ELEMHIDEEXCEPTION;
+
+  do
+  {
+    // Is this a CSS property rule maybe?
+    DependentString searchString(u"[-abp-properties="_str);
+    data.mPrefixEnd = text.find(searchString, data.mSelectorStart);
+    if (data.mPrefixEnd == text.npos ||
+        data.mPrefixEnd + searchString.length() + 1 >= text.length())
+    {
+      break;
+    }
+
+    data.mRegexpStart = data.mPrefixEnd + searchString.length() + 1;
+    char16_t quotation = text[data.mRegexpStart - 1];
+    if (quotation != u'\'' && quotation != u'"')
+      break;
+
+    data.mRegexpEnd = text.find(quotation, data.mRegexpStart);
+    if (data.mRegexpEnd == text.npos || data.mRegexpEnd + 1 >= text.length() ||
+      text[data.mRegexpEnd + 1] != u']')
+    {
+      break;
+    }
+
+    data.mSuffixStart = data.mRegexpEnd + 2;
+    return Type::CSSPROPERTY;
+  } while (false);
+
+  return Type::ELEMHIDE;
 }
 
-ElemHideBase* ElemHideBase::Create(const std::u16string& text)
+OwnedString ElemHideBase::GetSelectorDomain() const
 {
-  size_t domainsEnd;
-  size_t selectorStart;
-  Type type = Parse(text, &domainsEnd, &selectorStart);
-  if (type == Type::UNKNOWN)
-    return nullptr;
-  else if (type == Type::ELEMHIDEEXCEPTION)
-    return new ElemHideException(text, domainsEnd, selectorStart);
-  else
-    return new ElemHideFilter(text, domainsEnd, selectorStart);
+  /* TODO this is inefficient */
+  OwnedString result;
+  if (mDomains)
+  {
+    for (auto it = mDomains->begin(); it != mDomains->end(); ++it)
+    {
+      if (it->second && !it->first.empty())
+      {
+        if (!result.empty())
+          result.append(u',');
+        result.append(it->first);
+      }
+    }
+  }
+  return result;
 }