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

compiled/RegExpFilter.cpp

 #include <climits>
 
 #include <emscripten.h>
 
 #include "RegExpFilter.h"
 #include "StringScanner.h"
 #include "StringMap.h"
 
 namespace
 {
@@ skipping 33 matching lines @@
     {u"media"_str, TYPE_MEDIA},
     {u"font"_str, TYPE_FONT},
     {u"background"_str, TYPE_IMAGE},   // Backwards compat
 
     {u"popup"_str, TYPE_POPUP},
     {u"genericblock"_str, TYPE_GENERICBLOCK},
     {u"generichide"_str, TYPE_GENERICHIDE},
     {u"elemhide"_str, TYPE_ELEMHIDE},
   };
 
-  int defaultTypeMask = INT_MAX & ~(TYPE_DOCUMENT | TYPE_ELEMHIDE | TYPE_POPUP |
-      TYPE_GENERICBLOCK | TYPE_GENERICHIDE);
+  const int defaultTypeMask = INT_MAX & ~(TYPE_DOCUMENT | TYPE_ELEMHIDE |
+      TYPE_POPUP | TYPE_GENERICBLOCK | TYPE_GENERICHIDE);
 
   int GenerateRegExp(const String& regexp, bool matchCase)
   {
     return EM_ASM_INT(return regexps.create($0, $1), &regexp, matchCase);
   }
 
-  void NormalizeWhitespace(String& text)
+  void NormalizeWhitespace(DependentString& text)
   {
     // We want to remove all spaces but bail out early in the common scenario
     // that the string contains no spaces.
 
     // Look for the first space
     String::size_type len = text.length();
     String::size_type pos;
     for (pos = 0; pos < len; pos++)
       if (text[pos] == ' ')
         break;
 
     if (pos >= len)
       return;
 
     // Found spaces, move characters to remove them
     String::size_type delta = 1;
     for (pos = pos + 1; pos < len; pos++)
     {
       if (text[pos] == ' ')
         delta++;
       else
         text[pos - delta] = text[pos];
     }
     text.reset(text, 0, len - delta);
   }
-}
-
-RegExpFilter::RegExpFilter(const String& text, const RegExpFilterData& data)
-    : ActiveFilter(text, true), RegExpFilterData(data)
+
+  void ParseOption(String& text, DependentString& error, RegExpFilterData& data,
+      int optionStart, int optionEnd, int valueStart, int valueEnd)
+  {
+    if (optionEnd <= optionStart)
+      return;
+
+    bool reverse = false;
+    if (text[optionStart] == u'~')
+    {
+      reverse = true;
+      optionStart++;
+    }
+
+    DependentString name(text, optionStart, optionEnd - optionStart);
+    for (size_t i = 0; i < name.length(); ++i)
+    {
+      char16_t currChar = name[i];
+      if (currChar >= u'A' && currChar <= u'Z')
+        name[i] = currChar + u'a' - u'A';
+      else if (currChar == u'_')
+        name[i] = u'-';
+    }
+
+    auto it = typeMap.find(name);
+    if (it)
+    {
+      if (data.mContentType < 0)
+        data.mContentType = reverse ? defaultTypeMask : 0;
+      if (reverse)
+        data.mContentType &= ~it->second;
+      else
+        data.mContentType |= it->second;
+    }
+    else if (name.equals(u"domain"_str))
+    {
+      if (valueStart >= 0 && valueEnd > valueStart)
+      {
+        data.mDomainsStart = valueStart;
+        data.mDomainsEnd = valueEnd;
+        DependentString(text, valueStart, valueEnd - valueStart).toLower();
+      }
+    }
+    else if (name.equals(u"sitekey"_str))
+    {
+      if (valueStart >= 0 && valueEnd > valueStart)
+      {
+        data.mSitekeysStart = valueStart;
+        data.mSitekeysEnd = valueEnd;
+      }
+    }
+    else if (name.equals(u"match-case"_str))
+      data.mMatchCase = !reverse;
+    else if (name.equals(u"third-party"_str))
+      data.mThirdParty = reverse ? TrippleState::NO : TrippleState::YES;
+    else if (name.equals(u"collapse"_str))
+      data.mCollapse = reverse ? TrippleState::NO : TrippleState::YES;
+    else
+      error.reset(u"filter_unknown_option"_str);
+  }
+
+  void ParseOptions(String& text, DependentString& error, RegExpFilterData& data,
+      String::size_type optionsStart)
+  {
+    data.mMatchCase = false;
+    data.mThirdParty = TrippleState::ANY;
+    data.mCollapse = TrippleState::ANY;
+    data.mDomainsStart = String::npos;
+    data.mSitekeysStart = String::npos;
+    if (optionsStart >= text.length())
+    {
+      data.mContentType = defaultTypeMask;
+      return;
+    }
+
+    data.mContentType = -1;
+
+    int optionStart = data.mPatternEnd + 1;
+    int optionEnd = -1;
+    int valueStart = -1;
+
+    StringScanner scanner(text, optionStart, u',');
+    bool done = false;
+    while (!done)
+    {
+      done = scanner.done();
+      switch (scanner.next())
+      {
+        case u'=':
+          if (optionEnd < 0)
+          {
+            optionEnd = scanner.position();
+            valueStart = optionEnd + 1;
+          }
+          break;
+        case u',':
+          if (optionEnd < 0)
+            optionEnd = scanner.position();
+          ParseOption(text, error, data, optionStart, optionEnd, valueStart,
+              scanner.position());
+          if (!error.empty())
+            return;
+
+          optionStart = scanner.position() + 1;
+          optionEnd = -1;
+          valueStart = -1;
+          break;
+      }
+    }
+
+    if (data.mContentType < 0)
+      data.mContentType = defaultTypeMask;
+  }
+}
+
+RegExpFilter::RegExpFilter(Type type, const String& text, const RegExpFilterData& data)
+    : ActiveFilter(type, text, true), mData(data)
 {
 }
 
 RegExpFilter::~RegExpFilter()
 {
-  if (HasRegExp())
-    EM_ASM_ARGS(regexps.delete($0), mRegexpId);
-}
-
-Filter::Type RegExpFilter::Parse(String& text, String& error,
+  if (mData.HasRegExp())
+    EM_ASM_ARGS(regexps.delete($0), mData.mRegexpId);
+}
+
+Filter::Type RegExpFilter::Parse(DependentString& text, DependentString& error,
     RegExpFilterData& data)
 {
   NormalizeWhitespace(text);
 
-  bool blocking = true;
+  Filter::Type type = Type::BLOCKING;
 
   data.mPatternStart = 0;
   if (text.length() >= 2 && text[0] == u'@' && text[1] == u'@')
   {
-    blocking = false;
+    type = Type::WHITELIST;
     data.mPatternStart = 2;
   }
 
   data.mPatternEnd = text.find(u'$', data.mPatternStart);
   if (data.mPatternEnd == text.npos)
     data.mPatternEnd = text.length();
 
   ParseOptions(text, error, data, data.mPatternEnd + 1);
   if (!error.empty())
     return Type::INVALID;
 
   if (data.mPatternEnd - data.mPatternStart >= 2 &&
       text[data.mPatternStart] == u'/' &&
       text[data.mPatternEnd - 1] == u'/')
   {
-    data.SetRegExp(GenerateRegExp(String(text, data.mPatternStart + 1,
+    data.SetRegExp(GenerateRegExp(DependentString(text, data.mPatternStart + 1,
         data.mPatternEnd - data.mPatternStart - 2), data.mMatchCase));
-
-    int errorLength = EM_ASM_INT(return regexps.getErrorLength($0),
-        data.mRegexpId);
-    if (errorLength >= 0)
-    {
-      String regexpError(errorLength);
-      EM_ASM_ARGS(regexps.getError($0, $1), data.mRegexpId, regexpError.data());
-      error.reset(std::move(regexpError));
+    if (data.mRegexpId == -1)
+    {
+      error.reset(u"filter_invalid_regexp"_str);
       return Type::INVALID;
     }
   }
 
-  if (blocking)
-    return Type::BLOCKING;
-  else
-    return Type::WHITELIST;
-}
-
-void RegExpFilter::ParseOptions(String& text, String& error,
-    RegExpFilterData& data, String::size_type optionsStart)
-{
-  data.mMatchCase = false;
-  data.mThirdParty = TrippleState::ANY;
-  data.mCollapse = TrippleState::ANY;
-  data.mDomainsStart = String::npos;
-  data.mSitekeysStart = String::npos;
-  if (optionsStart >= text.length())
-  {
-    data.mContentType = defaultTypeMask;
-    return;
-  }
-
-  data.mContentType = -1;
-
-  int optionStart = data.mPatternEnd + 1;
-  int optionEnd = -1;
-  int valueStart = -1;
-
-  StringScanner scanner(text, optionStart, u',');
-  bool done = false;
-  while (!done)
-  {
-    done = scanner.done();
-    switch (scanner.next())
-    {
-      case u'=':
-        if (optionEnd < 0)
-        {
-          optionEnd = scanner.position();
-          valueStart = optionEnd + 1;
-        }
-        break;
-      case u',':
-        if (optionEnd < 0)
-          optionEnd = scanner.position();
-        ParseOption(text, error, data, optionStart, optionEnd, valueStart,
-            scanner.position());
-        if (!error.empty())
-          return;
-
-        optionStart = scanner.position() + 1;
-        optionEnd = -1;
-        valueStart = -1;
-        break;
-    }
-  }
-
-  if (data.mContentType < 0)
-    data.mContentType = defaultTypeMask;
-}
-
-void RegExpFilter::ParseOption(String& text, String& error,
-    RegExpFilterData& data, int optionStart, int optionEnd, int valueStart,
-    int valueEnd)
-{
-  if (optionEnd <= optionStart)
-    return;
-
-  bool reverse = false;
-  if (text[optionStart] == u'~')
-  {
-    reverse = true;
-    optionStart++;
-  }
-
-  String name(text, optionStart, optionEnd - optionStart);
-  for (size_t i = 0; i < name.length(); ++i)
-  {
-    char16_t currChar = name[i];
-    if (currChar >= u'A' && currChar <= u'Z')
-      name[i] = currChar + u'a' - u'A';
-    else if (currChar == u'_')
-      name[i] = u'-';
-  }
-
-  auto it = typeMap.find(name);
-  if (it != typeMap.end())
-  {
-    if (data.mContentType < 0)
-      data.mContentType = reverse ? defaultTypeMask : 0;
-    if (reverse)
-      data.mContentType &= ~it->second;
-    else
-      data.mContentType |= it->second;
-  }
-  else if (name.equals(u"domain"_str))
-  {
-    if (valueStart >= 0 && valueEnd > valueStart)
-    {
-      data.mDomainsStart = valueStart;
-      data.mDomainsEnd = valueEnd;
-      ToLower(text, data.mDomainsStart, data.mDomainsEnd);
-    }
-  }
-  else if (name.equals(u"sitekey"_str))
-  {
-    if (valueStart >= 0 && valueEnd > valueStart)
-    {
-      data.mSitekeysStart = valueStart;
-      data.mSitekeysEnd = valueEnd;
-    }
-  }
-  else if (name.equals(u"match-case"_str))
-    data.mMatchCase = !reverse;
-  else if (name.equals(u"third-party"_str))
-    data.mThirdParty = reverse ? TrippleState::NO : TrippleState::YES;
-  else if (name.equals(u"collapse"_str))
-    data.mCollapse = reverse ? TrippleState::NO : TrippleState::YES;
-  else
-  {
-    error.reset(u"Unknown option "_str);
-    error.append(name);
-  }
+  return type;
 }
 
 void RegExpFilter::ParseSitekeys(const String& sitekeys) const
 {
   StringScanner scanner(sitekeys, 0, u'|');
   size_t start = 0;
   bool done = false;
   while (!done)
   {
     done = scanner.done();
     if (scanner.next() == u'|')
     {
       if (scanner.position() > start)
-        AddSitekey(String(sitekeys, start, scanner.position() - start));
+        AddSitekey(DependentString(sitekeys, start, scanner.position() - start));
       start = scanner.position() + 1;
     }
   }
 }
 
 void RegExpFilter::InitJSTypes()
 {
   EM_ASM(exports.RegExpFilter.typeMap = {};);
   for (auto it = typeMap.begin(); it != typeMap.end(); ++it)
-    EM_ASM_ARGS(exports.RegExpFilter.typeMap[getStringData($0).replace("-", "_").toUpperCase()] = $1, &(it->first), it->second);
-}
-
-String RegExpFilter::RegExpFromSource(const String& source)
+    EM_ASM_ARGS(exports.RegExpFilter.typeMap[readString($0).replace("-", "_").toUpperCase()] = $1, &(it->first), it->second);
+}
+
+OwnedString RegExpFilter::RegExpFromSource(const String& source)
 {
   /* TODO: this is very inefficient */
 
   // Note: This doesn't remove trailing wildcards, otherwise the result should
   // be identical to Filter.toRegExp().
-  String result;
+  OwnedString result;
   String::value_type prevChar = u'*';
   for (String::size_type i = 0; i < source.length(); ++i)
   {
     String::value_type currChar = source[i];
     switch (currChar)
     {
       case u'*':
         if (prevChar != u'*')
           result.append(u".*"_str);
         break;
@@ skipping 29 matching lines @@
             !(currChar >= u'A' && currChar <= u'Z') &&
             !(currChar >= u'0' && currChar <= u'9') &&
             currChar < 128)
         {
           result.append(u'\\');
         }
         result.append(currChar);
     }
     prevChar = currChar;
   }
-  return std::move(result.ensure_own_buffer());
-}
-
-Filter::Type RegExpFilter::GetType() const
-{
-  return Type::BLOCKING;
+  return result;
 }
 
 RegExpFilter::DomainMap* RegExpFilter::GetDomains() const
 {
-  if (!DomainsParsingDone())
-  {
-    ParseDomains(GetDomainsSource(mText), u'|');
-    SetDomainsParsingDone();
+  if (!mData.DomainsParsingDone())
+  {
+    ParseDomains(mData.GetDomainsSource(mText), u'|');
+    mData.SetDomainsParsingDone();
   }
   return ActiveFilter::GetDomains();
 }
 
 RegExpFilter::SitekeySet* RegExpFilter::GetSitekeys() const
 {
-  if (!SitekeyParsingDone())
-  {
-    ParseSitekeys(GetSitekeysSource(mText));
-    SetSitekeysParsingDone();
+  if (!mData.SitekeyParsingDone())
+  {
+    ParseSitekeys(mData.GetSitekeysSource(mText));
+    mData.SetSitekeysParsingDone();
   }
   return ActiveFilter::GetSitekeys();
 }
 
 bool RegExpFilter::Matches(const String& location, int typeMask,
-    String& docDomain, bool thirdParty, const String& sitekey) const
-{
-  if (!(mContentType & typeMask) ||
-      (mThirdParty == TrippleState::YES && !thirdParty) ||
-      (mThirdParty == TrippleState::NO && thirdParty) ||
+    DependentString& docDomain, bool thirdParty, const String& sitekey) const
+{
+  if (!(mData.mContentType & typeMask) ||
+      (mData.mThirdParty == TrippleState::YES && !thirdParty) ||
+      (mData.mThirdParty == TrippleState::NO && thirdParty) ||
       !IsActiveOnDomain(docDomain, sitekey))
   {
     return false;
   }
 
-  if (!RegExpParsingDone())
-  {
-    const String pattern(GetRegExpSource(mText));
-    SetRegExp(GenerateRegExp(RegExpFromSource(pattern), mMatchCase));
-  }
-  return EM_ASM_INT(return regexps.test($0, $1), mRegexpId, &location);
-}
+  if (!mData.RegExpParsingDone())
+  {
+    const OwnedString pattern(mData.GetRegExpSource(mText));
+    mData.SetRegExp(GenerateRegExp(RegExpFromSource(pattern), mData.mMatchCase));
+  }
+  return EM_ASM_INT(return regexps.test($0, $1), mData.mRegexpId, &location);
+}