Issue 5142 - Convert Element Hiding to C++

compiled/ElemHide.cpp

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-present eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 17 matching lines @@
 }
 
 void ElemHide::Clear()
 {
   mFilters.clear();
   mExceptions.clear();
   mFiltersByDomain.clear();
   mKnownExceptions.clear();
 }
 
-const ActiveFilter::DomainMap ElemHide::defaultDomains = {
-  { ActiveFilter::DEFAULT_DOMAIN, true }
-};
-
-void ElemHide::AddToFiltersByDomain(ElemHideBase& filter)
-{
-  const auto* domains = filter.GetDomains();
+namespace
+{
+  const ActiveFilter::DomainMap defaultDomains =
+  {
+    { ActiveFilter::DEFAULT_DOMAIN, true }
+  };
+}
+
+void ElemHide::AddToFiltersByDomain(const ElemHideBasePtr& filter)
+{
+  const auto* domains = filter->GetDomains();
   if (!domains)
     domains = &defaultDomains;
 
-  DependentString text(filter.GetText());
+  DependentString text(filter->GetText());
   for (const auto& domain : *domains)
   {
     auto& filters = mFiltersByDomain[domain.first];
     if (domain.second)
-      filters[text] = ElemHideBasePtr(&filter);
+      filters[text] = filter;
     else
       filters[text] = ElemHideBasePtr();
   }
 }
 
 void ElemHide::Add(ElemHideBase& filter)
 {
   // we must ensure we have the right class.
   // This is an error, but we might get Invalid filters.
   if (!filter.As<ElemHideBase>())
     return;
 
   DependentString text(filter.GetText());
   if (filter.mType == Filter::Type::ELEMHIDEEXCEPTION)
   {
     if (mKnownExceptions.find(text))
       return;
 
     auto selector = filter.GetSelector();
     mExceptions[selector].emplace_back(filter.As<ElemHideException>());
 
     // Selector is no longer unconditional
     auto entry = mUnconditionalSelectors.find(selector);
-    if (entry)
-    {
-      AddToFiltersByDomain(*mFilters[entry->second]);
+    if (entry && entry->second)
+    {
+      AddToFiltersByDomain(entry->second);
       mUnconditionalSelectors.erase(selector);
       mUnconditionalSelectorsCache.reset();
     }
     mKnownExceptions.insert(text);
   }
   else
   {
     if (mFilters.find(text))
       return;
 
     auto selector = filter.GetSelector();
     mFilters[text] = &filter;
     if (!((filter.GetDomains() && filter.GetDomains()->size()) ||
           mExceptions.find(selector)))
     {
       // The new filter's selector is unconditionally applied to all domains
-      mUnconditionalSelectors[selector] = DependentString(filter.GetText());
+      mUnconditionalSelectors[selector] = ElemHideBasePtr(&filter);
       mUnconditionalSelectorsCache.reset();
     }
     else
-      AddToFiltersByDomain(filter);
+      AddToFiltersByDomain(ElemHideBasePtr(&filter));
   }
 }
 
 void ElemHide::Remove(ElemHideBase& filter)
 {
   DependentString text(filter.GetText());
 
   auto selector = filter.GetSelector();
   auto exceptionFilter = filter.As<ElemHideException>();
   if (exceptionFilter)
@@ skipping 40 matching lines @@
                                           DependentString& docDomain) const
 {
   auto exception = mExceptions.find(filter.GetSelector());
   if (!exception)
     return nullptr;
 
   auto& list = exception->second;
   for (auto iter = list.rbegin(); iter != list.rend(); iter++)
   {
     DependentString domain(docDomain);
-    if ((*iter)->IsActiveOnDomain(domain, DependentString()))
+    if (*iter && (*iter)->IsActiveOnDomain(domain))
     {
       ElemHideExceptionPtr filter(*iter);
       return filter.release();
     }
   }
 
   return nullptr;
 }
 
 ElemHide_SelectorList* ElemHide::GetUnconditionalSelectors() const
 {
   if (!mUnconditionalSelectorsCache)
   {
     mUnconditionalSelectorsCache =
       intrusive_ptr<ElemHide_SelectorList>(new ElemHide_SelectorList(), false);
     annotate_address(mUnconditionalSelectorsCache.get(), "ElemHide_SelectorList");
-    for (auto unconditional : mUnconditionalSelectors)
+    for (const auto& unconditional : mUnconditionalSelectors)
     {
       if (!(unconditional.is_deleted() || unconditional.is_invalid()))
       {
-        auto entry = mFilters.find(unconditional.second);
+        auto entry = mFilters.find(unconditional.second->GetText());
         if (entry)
           mUnconditionalSelectorsCache->push_back(entry->second);
       }
     }
   }
   return intrusive_ptr<ElemHide_SelectorList>(mUnconditionalSelectorsCache).release();
 }
 
 ElemHide_SelectorList* ElemHide::GetSelectorsForDomain(const String& domain,
   Criteria criteria) const
@@ skipping 38 matching lines @@
     if (currentDomain.empty())
       break;
 
     auto nextDot = currentDomain.find(u'.');
     currentDomain = nextDot == String::npos ?
       u""_str : DependentString(currentDomain, nextDot + 1);
   }
 
   return selectors.release();
 }