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
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "ElemHide.h"
 
 OwnedString ElemHide_SelectorList::SelectorAt(size_t idx) const
 {
-  return std::move(mSelectors[idx]->GetSelector());

[sergei, 2018/01/15 15:31:18]

std::move is redundant for return values.

[hub, 2018/01/16 02:57:38]

Done.

+  return mSelectors[idx]->GetSelector();
 }
 
 const String& ElemHide_SelectorList::FilterKeyAt(size_t idx) const
 {
   return mSelectors[idx]->GetText();
 }
-
-ElemHide* ElemHide::mInstance = new ElemHide();
 
 void ElemHide::Clear()
 {
   mFilters.clear();
   mExceptions.clear();
   mFiltersByDomain.clear();
   mKnownExceptions.clear();
 }
 
-namespace {
-
-  ActiveFilter::DomainMap* DefaultDomains()

[sergei, 2018/01/15 15:31:17]

What about just making it as a variable? AFAIK the map object can be initialized
in constructor.
In addition, it should be const.

[hub, 2018/01/16 02:57:37]

Done, but I can't make it const since we need to set it up.

-  {
-    static ActiveFilter::DomainMap defaultDomains;
-    if (defaultDomains.empty())
-      defaultDomains[u""_str] = true;
-    return &defaultDomains;
-  }
-
-}
-
-void ElemHide::AddToFiltersByDomain(ElemHideBase& filter)
-{
-  auto domains = filter.GetDomains();

[sergei, 2018/01/15 15:31:17]

it should be `const auto domains`.

[hub, 2018/01/16 02:57:37]

this would prevent line 56 from compiling because it makes the variable (pointer
type) const and not the dereferenced type.

[sergei, 2018/01/16 16:43:57]

One should use `const auto* domains = `.

[hub, 2018/01/19 02:11:02]

Done.

+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());
-  for (auto& domain : *domains)
+    domains = &defaultDomains;
+
+  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
-    {
-      auto iter = filters.find(text);
-      if (iter != filters.end())
-        filters.erase(iter);
-    }
+      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>())

[sergei, 2018/01/15 15:31:16]

`filter` type is already `ElemHideBase`, it looks redundant. If it's possible to
construct `ElemHideBase` with a type which does not include the type of
ElemHideBase then we should change that IMO.

[hub, 2018/01/16 02:57:36]

It is not. The bindings don't guarantee it and in the tests
(`testDomainRestrictions`) we get filters of the wrong type. This ensure it
doesn't happen.

[sergei, 2018/01/16 16:43:56]

Acknowledged, then let's keep it as is.

     return;
 
   DependentString text(filter.GetText());
   if (filter.mType == Filter::Type::ELEMHIDEEXCEPTION)
   {
     if (mKnownExceptions.find(text))
       return;
 
     auto selector = filter.GetSelector();
-    mExceptions[selector].push_back(

[sergei, 2018/01/15 15:31:16]

with emplace_back it's not necessary to use ElemHideExceptionPtr.

[hub, 2018/01/16 02:57:38]

Done.

-      ElemHideExceptionPtr(filter.As<ElemHideException>()));
-
-    // Selector is not longer unconditional
-    mUnconditionalSelectors.erase(text);
-    mUnconditionalSelectorsCache.reset();
+    mExceptions[selector].emplace_back(filter.As<ElemHideException>());
+
+    // Selector is no longer unconditional
+    auto entry = mUnconditionalSelectors.find(selector);
+    if (entry && entry->second)
+    {
+      AddToFiltersByDomain(entry->second);
+      mUnconditionalSelectors.erase(selector);
+      mUnconditionalSelectorsCache.reset();
+    }
     mKnownExceptions.insert(text);
   }
   else
   {
     if (mFilters.find(text))
       return;
 
-    mFilters[text] = ElemHideBasePtr(filter.As<ElemHideBase>());

[sergei, 2018/01/15 15:31:17]

ElemHideBasePtr is not required here.

[hub, 2018/01/16 02:57:36]

Done.

+    auto selector = filter.GetSelector();
+    mFilters[text] = &filter;
     if (!((filter.GetDomains() && filter.GetDomains()->size()) ||
-          mExceptions.find(filter.GetSelector())))
+          mExceptions.find(selector)))
     {
       // The new filter's selector is unconditionally applied to all domains
-      mUnconditionalSelectors.insert(text);
+      mUnconditionalSelectors[selector] = ElemHideBasePtr(&filter);
       mUnconditionalSelectorsCache.reset();
     }
     else
-      AddToFiltersByDomain(filter);
+      AddToFiltersByDomain(ElemHideBasePtr(&filter));
   }
 }
 
 void ElemHide::Remove(ElemHideBase& filter)
 {
   DependentString text(filter.GetText());
 
-  if (filter.mType == Filter::Type::ELEMHIDEEXCEPTION)
+  auto selector = filter.GetSelector();
+  auto exceptionFilter = filter.As<ElemHideException>();
+  if (exceptionFilter)
   {
     // never seen the exception.
     if (!mKnownExceptions.find(text))
       return;
 
-    auto selector = filter.GetSelector();
     auto& list = mExceptions[selector];
-    auto iter = std::find(
-      list.begin(), list.end(),
-      ElemHideExceptionPtr(filter.As<ElemHideException>()));
+    auto iter = std::find(list.begin(), list.end(),
+                          ElemHideExceptionPtr(exceptionFilter));
     if (iter != list.end())
       list.erase(iter);
     mKnownExceptions.erase(text);
   }
   else
   {
     if (!mFilters.find(text))
       return;
 
-    if (mUnconditionalSelectors.find(text))
-    {
-      mUnconditionalSelectors.erase(text);
+    if (mUnconditionalSelectors.find(selector))
+    {
+      mUnconditionalSelectors.erase(selector);
       mUnconditionalSelectorsCache.reset();
     }
     else
     {
-      auto domains = filter.GetDomains();
-      for (auto domain : *domains)
+      const auto* domains = filter.GetDomains();
+      if (!domains)
+        domains = &defaultDomains;
+
+      for (const auto& domain : *domains)
       {
         auto& list = mFiltersByDomain[domain.first];
         list.erase(text);
       }
     }
 
     mFilters.erase(text);
   }
 }
 
 ElemHideException* ElemHide::GetException(const ElemHideBase& filter,
                                           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, u""_str))

[sergei, 2018/01/15 15:31:17]

should the sitekey parameter be the invalid string (DependentString)?

[hub, 2018/01/16 02:57:38]

It's probably better.

+    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);

[sergei, 2018/01/15 15:31:16]

it woule be better to have it `new X()` with parentheses.

[hub, 2018/01/16 02:57:38]

Done.

+    mUnconditionalSelectorsCache =
+      intrusive_ptr<ElemHide_SelectorList>(new ElemHide_SelectorList(), false);
     annotate_address(mUnconditionalSelectorsCache.get(), "ElemHide_SelectorList");
-    for (auto unconditional : mUnconditionalSelectors)
-    {
-      auto filter = mFilters.find(unconditional.first);

[sergei, 2018/01/15 15:31:18]

what do you think about renaming it to something reflecting that it's not a
filter, it's a reference? BTW, it seems it can return a deleted bucket, we
should be really careful with it everywhere...

[hub, 2018/01/16 02:57:36]

We check the entry just below and if it has been deleted, we do nothing.

Renaming `filter` to `entry`.

[sergei, 2018/01/16 16:43:56]

It's actually correct but I thought that find (which calls find_bucket) can also
return deleted entries, fortunately according to find_bucket it can return
either an invalid bucket or a bucket with a payload, so checking below whether
it's an invalid is enough.

-      if (filter)
-        mUnconditionalSelectorsCache->push_back(filter->second);
+    for (const auto& unconditional : mUnconditionalSelectors)
+    {
+      if (!(unconditional.is_deleted() || unconditional.is_invalid()))
+      {
+        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
 {
-  intrusive_ptr<ElemHide_SelectorList> selectors(new ElemHide_SelectorList);

[sergei, 2018/01/15 15:31:17]

it would be better to always use () or {} in new expressions, just for
consistency.

[hub, 2018/01/16 02:57:36]

Done.

+  intrusive_ptr<ElemHide_SelectorList> selectors(new ElemHide_SelectorList());
   annotate_address(selectors.get(), "ElemHide_SelectorList");
 
   if (criteria < NO_UNCONDITIONAL)
-    selectors->append(GetUnconditionalSelectors());

[sergei, 2018/01/15 15:31:18]

GetUnconditionalSelectors() returns a raw pointer to ref counted, so we should
delete it after the usage.

[hub, 2018/01/16 02:57:37]

Done.

-
-  bool specificOnly = (criteria >= SPECIFIC_ONLY);

[sergei, 2018/01/15 15:31:18]

I think it would be better to remove the parentheses here.

[hub, 2018/01/16 02:57:38]

Done.

+  {
+    intrusive_ptr<ElemHide_SelectorList> selector(GetUnconditionalSelectors());
+    selectors->append(*selector);
+  }
+
+  bool specificOnly = criteria >= SPECIFIC_ONLY;
   StringSet seenFilters;
   DependentString docDomain(domain);
 
   DependentString currentDomain(domain);
   while (true)
   {
     if (specificOnly && currentDomain.empty())
       break;
 
     auto filters = mFiltersByDomain.find(currentDomain);
     if (filters)
     {
-      for (auto& entry : filters->second)
+      for (const auto& entry : filters->second)
       {
-        if (entry.first.is_invalid())

[sergei, 2018/01/15 15:31:17]

should deleted be also filtered out?

[hub, 2018/01/16 02:57:36]

I think so. Done.

+        if (entry.first.is_invalid() || entry.first.is_deleted())
           continue;
 
         if (seenFilters.find(entry.first))
           continue;
         seenFilters.insert(entry.first);
 
         auto filter = entry.second;
         if (filter && !GetException(*filter, docDomain))
           selectors->push_back(filter);
       }
     }
 
     if (currentDomain.empty())
       break;
 
-    auto nextDot = currentDomain.find('.');

[sergei, 2018/01/15 15:31:16]

the parameter should be u'.'.

[hub, 2018/01/16 02:57:37]

Done.

+    auto nextDot = currentDomain.find(u'.');
     currentDomain = nextDot == String::npos ?
       u""_str : DependentString(currentDomain, nextDot + 1);
   }
 
   return selectors.release();
 }