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 std::u16string& text,
-    const std::u16string& domains, const std::u16string& selector)
-    : ActiveFilter(text, false), selector(selector)
+namespace
 {
-  if (!domains.empty())
-    ParseDomains(domains, 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 std::u16string& text, size_t* domainsEnd,
-    size_t* selectorStart, size_t* prefixEnd, size_t* regexpStart,
-    size_t* regexpEnd, size_t* 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
-  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;
     }
   }
 
+  // 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;
-    }
-
-    const std::u16string searchString(u"[-abp-properties=");
-    *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 std::u16string& text)
+OwnedString ElemHideBase::GetSelectorDomain() const
 {
-  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
+  /* TODO this is inefficient */
+  OwnedString result;
+  if (mDomains)
   {
-    std::u16string domains(text.substr(0, domainsEnd));
-    std::u16string selector(text.substr(selectorStart));
-    if (type == Type::ELEMHIDEEXCEPTION)
-      return new ElemHideException(text, domains, selector);
-    else if (type == Type::CSSPROPERTY)
+    for (auto it = mDomains->begin(); it != mDomains->end(); ++it)
     {
-      std::u16string prefix(text.substr(selectorStart, prefixEnd - selectorStart));
-      std::u16string regexpSource(text.substr(regexpStart, regexpEnd - regexpStart));
-      std::u16string suffix(text.substr(suffixStart));
-      return new CSSPropertyFilter(text, domains, selector, regexpSource, prefix,
-          suffix);
-    }
-    else
-      return new ElemHideFilter(text, domains, selector);
-  }
-  catch (const std::u16string& e)
-  {
-    return new InvalidFilter(text, e);
-  }
-}
-
-const std::u16string ElemHideBase::GetSelectorDomain() const
-{
-  std::u16string result;
-  for (auto it = domains.begin(); it != domains.end(); ++it)
-  {
-    if (it->second && !it->first.empty())
-    {
-      if (!result.empty())
-        result.append(u",");
-      result.append(it->first);
+      if (it->second && !it->first.empty())
+      {
+        if (!result.empty())
+          result.append(u',');
+        result.append(it->first);
+      }
     }
   }
   return result;
 }