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

compiled/ElemHideBase.cpp

 #include "ElemHideBase.h"
-#include "ElemHideFilter.h"
-#include "ElemHideException.h"
 #include "CSSPropertyFilter.h"
-#include "InvalidFilter.h"
 #include "StringScanner.h"
 
-ElemHideBase::ElemHideBase(const String& text,
-    String::size_type domainsEnd, String::size_type selectorStart)
-    : ActiveFilter(text, false),
-      mSelector(String(mText, selectorStart))
+namespace
 {
-  if (domainsEnd)
-    ParseDomains(mText, 0, domainsEnd, u',');
+  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.
+
+    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);
+  }
 }
 
-Filter::Type ElemHideBase::Parse(const String& text,
-    String::size_type* domainsEnd,
-    String::size_type* selectorStart,
-    String::size_type* prefixEnd,
-    String::size_type* regexpStart,
-    String::size_type* regexpEnd,
-    String::size_type* suffixStart)
+ElemHideBase::ElemHideBase(Type type, const String& text, const ElemHideBaseData& data)
+    : ActiveFilter(type, text, false), mData(data)
+{
+  if (mData.HasDomains())
+    ParseDomains(mData.GetDomainsSource(mText), u',');
+}
+
+Filter::Type ElemHideBase::Parse(DependentString& text, ElemHideData& data)
 {
   StringScanner scanner(text);
 
   // Domains part
+  bool seenSpaces = false;
   while (!scanner.done())
   {
     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;
+  seenSpaces |= scanner.skip(u' ');
+  bool exception = scanner.skipOne(u'@');
+  if (exception)
+    seenSpaces |= scanner.skip(u' ');
+
   String::value_type next = scanner.next();
-  if (next == u'@')
-  {
-    exception = true;
-    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;
     }
   }
 
+  // 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?
-    if (!prefixEnd)
-    {
-      // Caller doesn't care
-      break;
-    }
-
-    String searchString(u"[-abp-properties="_str);
-    *prefixEnd = text.find(searchString, *selectorStart);
-    if (*prefixEnd == text.npos ||
-        *prefixEnd + searchString.length() + 1 >= text.length())
+    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;
     }
 
-    *regexpStart = *prefixEnd + searchString.length() + 1;
-    char16_t quotation = text[*regexpStart - 1];
+    data.mRegexpStart = data.mPrefixEnd + searchString.length() + 1;
+    char16_t quotation = text[data.mRegexpStart - 1];
     if (quotation != u'\'' && quotation != u'"')
       break;
 
-    *regexpEnd = text.find(quotation, *regexpStart);
-    if (*regexpEnd == text.npos || *regexpEnd + 1 >= text.length() ||
-      text[*regexpEnd + 1] != u']')
+    data.mRegexpEnd = text.find(quotation, data.mRegexpStart);
+    if (data.mRegexpEnd == text.npos || data.mRegexpEnd + 1 >= text.length() ||
+      text[data.mRegexpEnd + 1] != u']')
     {
       break;
     }
 
-    *suffixStart = *regexpEnd + 2;
+    data.mSuffixStart = data.mRegexpEnd + 2;
     return Type::CSSPROPERTY;
   } while (false);
 
   return Type::ELEMHIDE;
 }
 
-Filter* ElemHideBase::Create(const String& text)
-{
-  size_t domainsEnd;
-  size_t selectorStart;
-  size_t prefixEnd;
-  size_t regexpStart;
-  size_t regexpEnd;
-  size_t suffixStart;
-  Type type = Parse(text, &domainsEnd, &selectorStart, &prefixEnd, &regexpStart,
-      &regexpEnd, &suffixStart);
-  if (type == Type::UNKNOWN)
-    return nullptr;
-
-  try
-  {
-    if (type == Type::ELEMHIDEEXCEPTION)
-      return new ElemHideException(text, domainsEnd, selectorStart);
-    else if (type == Type::CSSPROPERTY)
-    {
-      return new CSSPropertyFilter(text, domainsEnd, selectorStart, prefixEnd,
-          regexpStart, regexpEnd, suffixStart);
-    }
-    else
-      return new ElemHideFilter(text, domainsEnd, selectorStart);
-  }
-  catch (const String& e)
-  {
-    return new InvalidFilter(text, e);
-  }
-}
-
-String ElemHideBase::GetSelectorDomain() const
+OwnedString ElemHideBase::GetSelectorDomain() const
 {
   /* TODO this is inefficient */
-  String result;
+  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 std::move(result.ensure_own_buffer());
+  return result;
 }