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

compiled/ActiveFilter.cpp

+#include <cstdio>
+
 #include "ActiveFilter.h"
 #include "StringScanner.h"
 
 namespace
 {
-  const std::u16string ProcessDomain(const std::u16string& docDomain,
-      bool ignoreTrailingDot)
+  const DependentString DEFAULT_DOMAIN(u""_str);
+
+  OwnedString to_string(unsigned int i)
   {
-    size_t len = docDomain.length();
-    if (ignoreTrailingDot)
-    {
-      for (; len > 0; --len)
-      {
-        if (docDomain[len - 1] != u'.')
-          break;
-      }
-    }
+    char buffer[11];
+    int len = sprintf(buffer, "%u", i);
 
-    std::u16string domain(docDomain.substr(0, len));
-    for (size_t i = 0, l = domain.length(); i < l; ++i)
-    {
-      char16_t currChar = domain[i];
-      // TODO: This needs to work for non-ASCII as well
-      if (currChar >= u'a' && currChar <= u'z')
-        domain[i] = currChar + u'A' - u'a';
-    }
-    return domain;
-  }
-
-  const std::u16string to_u16string(unsigned int i)
-  {
-    std::string str(std::to_string(i));
-    std::u16string result(str.length(), u'\0');
-
-    for (size_t i = 0, l = str.length(); i < l; ++i)
-      result[i] = str[i];
+    OwnedString result(len);
+    for (String::size_type i = 0; i < len; i++)
+      result[i] = buffer[i];
     return result;
   }
 }
 
-ActiveFilter::ActiveFilter(const std::u16string& text, bool ignoreTrailingDot)
-    : Filter(text), disabled(false), hitCount(0), lastHit(0),
-      ignoreTrailingDot(ignoreTrailingDot)
+ActiveFilter::ActiveFilter(Type type, const String& text, bool ignoreTrailingDot)
+    : Filter(type, text), mDisabled(false), mHitCount(0), mLastHit(0),
+      mIgnoreTrailingDot(ignoreTrailingDot)
 {
 }
 
-void ActiveFilter::ParseDomains(const std::u16string& str, char16_t separator)
+ActiveFilter::DomainMap* ActiveFilter::GetDomains() const
 {
-  StringScanner scanner(str + separator);
-  size_t start = 0;
+  return mDomains.get();
+}
+
+ActiveFilter::SitekeySet* ActiveFilter::GetSitekeys() const
+{
+  return mSitekeys.get();
+}
+
+void ActiveFilter::ParseDomains(const String& domains,
+    String::value_type separator) const
+{
+  DomainMap::size_type count = 2;
+  for (String::size_type i = 0; i < domains.length(); i++)
+    if (domains[i] == separator)
+      count++;
+
+  mDomains.reset(new DomainMap(count));
+  annotate_address(mDomains.get(), "DomainMap");
+
+  StringScanner scanner(domains, 0, separator);
+  String::size_type start = 0;
   bool reverse = false;
   bool hasIncludes = false;
-  while (!scanner.done())
+  bool done = scanner.done();
+  while (!done)
   {
-    char16_t currChar = scanner.next();
+    done = scanner.done();
+    String::value_type currChar = scanner.next();
     if (currChar == u'~' && scanner.position() == start)
     {
       start++;
       reverse = true;
     }
     else if (currChar == separator)
     {
-      if (scanner.position() > start)
+      String::size_type len = scanner.position() - start;
+      if (len > 0 && mIgnoreTrailingDot && domains[start + len - 1] == '.')
+        len--;
+      if (len > 0)
       {
-        std::u16string domain(
-          ProcessDomain(str.substr(start, scanner.position() - start),
-              ignoreTrailingDot)
-        );
-        domains[domain] = !reverse;
+        enter_context("Adding to ActiveFilter.mDomains");
+        (*mDomains)[DependentString(domains, start, len)] = !reverse;
+        exit_context();
+
         if (!reverse)
           hasIncludes = true;
       }
       start = scanner.position() + 1;
       reverse = false;
     }
   }
-  domains[u""] = !hasIncludes;
+  enter_context("Adding to ActiveFilter.mDomains");
+  (*mDomains)[DEFAULT_DOMAIN] = !hasIncludes;
+  exit_context();
 }
 
+void ActiveFilter::AddSitekey(const String& sitekey) const
+{
+  if (!mSitekeys)
+  {
+    mSitekeys.reset(new SitekeySet());
+    annotate_address(mSitekeys.get(), "SitekeySet");
+  }
 
-bool ActiveFilter::IsActiveOnDomain(const std::u16string& docDomain,
-    const std::u16string& sitekey)
+  enter_context("Adding to ActiveFilter.mSitekeys");
+  mSitekeys->insert(sitekey);
+  exit_context();
+}
+
+bool ActiveFilter::IsActiveOnDomain(DependentString& docDomain, const String& sitekey) const
 {
-  if (!sitekeys.empty() && sitekeys.find(sitekey) == sitekeys.end())
+  auto sitekeys = GetSitekeys();
+  if (sitekeys && !sitekeys->find(sitekey))
     return false;
 
   // If no domains are set the rule matches everywhere
-  if (domains.empty())
+  auto domains = GetDomains();
+  if (!domains)
     return true;
 
   // If the document has no host name, match only if the filter isn't restricted
   // to specific domains
   if (docDomain.empty())
-    return domains[u""];
+    return (*domains)[DEFAULT_DOMAIN];
 
-  std::u16string domain(ProcessDomain(docDomain, ignoreTrailingDot));
+  docDomain.toLower();
+
+  String::size_type len = docDomain.length();
+  if (len > 0 && mIgnoreTrailingDot && docDomain[len - 1] == '.')
+    docDomain.reset(docDomain, 0, len - 1);
   while (true)
   {
-    auto it = domains.find(domain);
-    if (it != domains.end())
+    auto it = domains->find(docDomain);
+    if (it)
       return it->second;
 
-    size_t nextDot = domain.find(u'.');
-    if (nextDot == domain.npos)
+    String::size_type nextDot = docDomain.find(u'.');
+    if (nextDot == docDomain.npos)
       break;
-    domain = domain.substr(nextDot + 1);
+    docDomain.reset(docDomain, nextDot + 1);
   }
-  return domains[u""];
+  return (*domains)[DEFAULT_DOMAIN];
 }
 
-bool ActiveFilter::IsActiveOnlyOnDomain(const std::u16string& docDomain)
+bool ActiveFilter::IsActiveOnlyOnDomain(DependentString& docDomain) const
 {
-  if (domains.empty() || docDomain.empty() || domains[u""])
+  auto domains = GetDomains();
+  if (!domains || docDomain.empty() || (*domains)[DEFAULT_DOMAIN])
     return false;
 
-  std::u16string domain(ProcessDomain(docDomain, ignoreTrailingDot));
-  for (auto it = domains.begin(); it != domains.end(); ++it)
+  docDomain.toLower();
+
+  String::size_type len = docDomain.length();
+  if (len > 0 && mIgnoreTrailingDot && docDomain[len - 1] == '.')
+    docDomain.reset(docDomain, 0, len - 1);
+  for (auto it = domains->begin(); it != domains->end(); ++it)
   {
-    if (!it->second || it->first == domain)
+    if (!it->second || it->first.equals(docDomain))
       continue;
 
     size_t len1 = it->first.length();
-    size_t len2 = domain.length();
-    if (len1 > len2 && it->first.rfind(u"." + domain) == len1 - len2 - 1)
+    size_t len2 = docDomain.length();
+    if (len1 > len2 &&
+        DependentString(it->first, len1 - len2).equals(docDomain) &&
+        it->first[len1 - len2 - 1] == u'.')
+    {
       continue;
+    }
 
     return false;
   }
   return true;
 }
 
-bool ActiveFilter::IsGeneric()
+bool ActiveFilter::IsGeneric() const
 {
-  return (sitekeys.empty() && (domains.empty() || domains[u""]));
+  auto sitekeys = GetSitekeys();
+  auto domains = GetDomains();
+  return !sitekeys && (!domains || (*domains)[DEFAULT_DOMAIN]);
 }
 
-const std::u16string ActiveFilter::Serialize()
+OwnedString ActiveFilter::Serialize() const
 {
-  std::u16string result(Filter::Serialize());
-  if (disabled)
-    result += u"disabled=true\n";
-  if (hitCount)
-    result += u"hitCount=" + to_u16string(hitCount) + u"\n";
-  if (lastHit)
-    result += u"lastHit=" + to_u16string(lastHit) + u"\n";
+  /* TODO this is very inefficient */
+  OwnedString result(Filter::Serialize());
+  if (mDisabled)
+    result.append(u"disabled=true\n"_str);
+  if (mHitCount)
+  {
+    result.append(u"hitCount="_str);
+    result.append(to_string(mHitCount));
+    result.append(u'\n');
+  }
+  if (mLastHit)
+  {
+    result.append(u"lastHit="_str);
+    result.append(to_string(mLastHit));
+    result.append(u'\n');
+  }
   return result;
 }