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 107 matching lines @@
         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;
-        ActiveFilter::ToLower(DependentString(text, data.mDomainsStart,

[Wladimir Palant, 2016/02/23 12:37:47]

This should be valueStart rather than data.mDomainsStart of course, I already
fixed it in the repository.

-            valueEnd - valueStart));
+        DependentString(text, valueStart, valueEnd - valueStart).toLower();
       }
     }
     else if (name.equals(u"sitekey"_str))
     {
       if (valueStart >= 0 && valueEnd > valueStart)
       {
         data.mSitekeysStart = valueStart;
         data.mSitekeysEnd = valueEnd;
       }
     }
@@ skipping 54 matching lines @@
           valueStart = -1;
           break;
       }
     }
 
     if (data.mContentType < 0)
       data.mContentType = defaultTypeMask;
   }
 }
 
-RegExpFilter::RegExpFilter(const String& text, const RegExpFilterData& data)
-    : ActiveFilter(text, true), RegExpFilterData(data)
+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);
+  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(DependentString(text, data.mPatternStart + 1,
         data.mPatternEnd - data.mPatternStart - 2), data.mMatchCase));
     if (data.mRegexpId == -1)
     {
       error.reset(u"filter_invalid_regexp"_str);
       return Type::INVALID;
     }
   }
 
-  if (blocking)
-    return Type::BLOCKING;
-  else
-    return Type::WHITELIST;
+  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(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);
+    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().
   OwnedString result;
   String::value_type prevChar = u'*';
@@ skipping 43 matching lines @@
         }
         result.append(currChar);
     }
     prevChar = currChar;
   }
   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,
     DependentString& docDomain, bool thirdParty, const String& sitekey) const
 {
-  if (!(mContentType & typeMask) ||
-      (mThirdParty == TrippleState::YES && !thirdParty) ||
-      (mThirdParty == TrippleState::NO && thirdParty) ||
+  if (!(mData.mContentType & typeMask) ||
+      (mData.mThirdParty == TrippleState::YES && !thirdParty) ||
+      (mData.mThirdParty == TrippleState::NO && thirdParty) ||
       !IsActiveOnDomain(docDomain, sitekey))
   {
     return false;
   }
 
-  if (!RegExpParsingDone())
-  {
-    const OwnedString 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);
+}