Issue 119 - Switch to injecting CSS for element hiding

src/plugin/PluginFilter.cpp

+/*
+ * This file is part of Adblock Plus <https://adblockplus.org/>,
+ * Copyright (C) 2006-2016 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 "PluginStdAfx.h"
-
+#include "AdblockPlusClient.h"
 #include "PluginFilter.h"
 #include "PluginSettings.h"
-#include "PluginClient.h"
-#include "PluginClientFactory.h"
 #include "PluginMutex.h"
 #include "PluginSettings.h"
 #include "PluginSystem.h"
 #include "PluginClass.h"
 #include "mlang.h"
-
 #include "..\shared\CriticalSection.h"
 #include "..\shared\Utils.h"
-
+#include "..\shared\MsHTMLUtils.h"
 
 // The filters are described at http://adblockplus.org/en/filters
 
 static CriticalSection s_criticalSectionFilterMap;
-
-namespace
-{
-  struct GetHtmlElementAttributeResult
-  {
-    GetHtmlElementAttributeResult() : isAttributeFound(false)
-    {
-    }
-    std::wstring attributeValue;
-    bool isAttributeFound;
-  };
-
-  GetHtmlElementAttributeResult GetHtmlElementAttribute(IHTMLElement& htmlElement,
-    const ATL::CComBSTR& attributeName)
-  {
-    GetHtmlElementAttributeResult retValue;
-    ATL::CComVariant vAttr;
-    ATL::CComPtr<IHTMLElement4> htmlElement4;
-    if (FAILED(htmlElement.QueryInterface(&htmlElement4)) || !htmlElement4)
-    {
-      return retValue;
-    }
-    ATL::CComPtr<IHTMLDOMAttribute> attributeNode;
-    if (FAILED(htmlElement4->getAttributeNode(attributeName, &attributeNode)) || !attributeNode)
-    {
-      return retValue;
-    }
-    // we set that attribute found but it's not necessary that we can retrieve its value
-    retValue.isAttributeFound = true;
-    if (FAILED(attributeNode->get_nodeValue(&vAttr)))
-    {
-      return retValue;
-    }
-    if (vAttr.vt == VT_BSTR && vAttr.bstrVal)
-    {
-      retValue.attributeValue = vAttr.bstrVal;
-    }
-    else if (vAttr.vt == VT_I4)
-    {
-      retValue.attributeValue = std::to_wstring(vAttr.iVal);
-    }
-    return retValue;
-  }
-}
 
 // ============================================================================
 // CFilterElementHideAttrSelector
 // ============================================================================
 
 CFilterElementHideAttrSelector::CFilterElementHideAttrSelector() : m_type(TYPE_NONE), m_pos(POS_NONE), m_bstrAttr(NULL)
 {
 }
 
 CFilterElementHideAttrSelector::CFilterElementHideAttrSelector(const CFilterElementHideAttrSelector& filter)
@@ skipping 174 matching lines @@
   m_predecessor = filter.m_predecessor;
 }
 
 
 // ============================================================================
 // CFilter
 // ============================================================================
 
 CFilter::CFilter(const CFilter& filter)
 {
-  m_contentType = filter.m_contentType;
   m_filterType  = filter.m_filterType;
 
   m_isFirstParty = filter.m_isFirstParty;
   m_isThirdParty = filter.m_isThirdParty;
 
   m_isMatchCase  = filter.m_isMatchCase;
   m_isFromStart = filter.m_isFromStart;
   m_isFromEnd = filter.m_isFromEnd;
 
   m_filterText = filter.m_filterText;
 
   m_hitCount = filter.m_hitCount;
 }
 
 
-CFilter::CFilter() : m_isMatchCase(false), m_isFirstParty(false), m_isThirdParty(false), m_contentType(CFilter::contentTypeAny),
+CFilter::CFilter() : m_isMatchCase(false), m_isFirstParty(false),
+  m_isThirdParty(false),
   m_isFromStart(false), m_isFromEnd(false), m_hitCount(0)
 {
 }
 
 
 bool CFilterElementHide::IsMatchFilterElementHide(IHTMLElement* pEl) const
 {
   HRESULT hr;
 
   if (!m_tagId.IsEmpty())
@@ skipping 161 matching lines @@
 
   return true;
 }
 
 
 
 // ============================================================================
 // CPluginFilter
 // ============================================================================
 
-CPluginFilter::CPluginFilter(const CString& dataPath) : m_dataPath(dataPath)
-{
-  m_contentMapText[CFilter::contentTypeDocument] = "DOCUMENT";
-  m_contentMapText[CFilter::contentTypeObject] = "OBJECT";
-  m_contentMapText[CFilter::contentTypeObjectSubrequest] = "OBJECT_SUBREQUEST";
-  m_contentMapText[CFilter::contentTypeImage] = "IMAGE";
-  m_contentMapText[CFilter::contentTypeScript] = "SCRIPT";
-  m_contentMapText[CFilter::contentTypeOther] = "OTHER";
-  m_contentMapText[CFilter::contentTypeUnknown] = "OTHER";
-  m_contentMapText[CFilter::contentTypeSubdocument] = "SUBDOCUMENT";
-  m_contentMapText[CFilter::contentTypeStyleSheet] = "STYLESHEET";
-  m_contentMapText[CFilter::contentTypeXmlHttpRequest] = "XMLHTTPREQUEST";
-
-  ClearFilters(); 
-}
-
-
 bool CPluginFilter::AddFilterElementHide(CString filterText)
 {
   DEBUG_FILTER("Input: " + filterText + " filterFile" + filterFile);
   CriticalSection::Lock filterEngineLock(s_criticalSectionFilterMap);
   {
     CString filterString  = filterText;
     // Create filter descriptor
     std::auto_ptr<CFilterElementHide> filter;
 
     CString wholeFilterString = filterString;
@@ skipping 46 matching lines @@
         }
       }
     } while (separatorChar != '\0');
   }
 
   return true;
 }
 
 bool CPluginFilter::IsElementHidden(const std::wstring& tag, IHTMLElement* pEl, const std::wstring& domain, const std::wstring& indent) const
 {
-  CString tagCString = to_CString(tag);
+  CString tagCString = ToCString(tag);
 
   CString id;
   CComBSTR bstrId;
   if (SUCCEEDED(pEl->get_id(&bstrId)) && bstrId)
   {
     id = bstrId;
   }
 
   CString classNames;
   CComBSTR bstrClassNames;
   if (SUCCEEDED(pEl->get_className(&bstrClassNames)) && bstrClassNames)
   {
     classNames = bstrClassNames;
   }
 
   CriticalSection::Lock filterEngineLock(s_criticalSectionFilterMap);
   {
     // Search tag/id filters
     if (!id.IsEmpty())
     {
       std::pair<TFilterElementHideTagsNamed::const_iterator, TFilterElementHideTagsNamed::const_iterator> idItEnum =
         m_elementHideTagsId.equal_range(std::make_pair(tagCString, id));
       for (TFilterElementHideTagsNamed::const_iterator idIt = idItEnum.first; idIt != idItEnum.second; idIt ++)
       {
         if (idIt->second.IsMatchFilterElementHide(pEl))
         {
 #ifdef ENABLE_DEBUG_RESULT
           DEBUG_HIDE_EL(indent + "HideEl::Found (tag/id) filter:" + idIt->second.m_filterText)
-            CPluginDebug::DebugResultHiding(tagCString, "id:" + id, idIt->second.m_filterText);
+            CPluginDebug::DebugResultHiding(tag, L"id:" + ToWstring(id), ToWstring(idIt->second.m_filterText));
 #endif
           return true;
         }
       }
 
       // Search general id
       idItEnum = m_elementHideTagsId.equal_range(std::make_pair("", id));
       for (TFilterElementHideTagsNamed::const_iterator idIt = idItEnum.first; idIt != idItEnum.second; idIt ++)
       {
         if (idIt->second.IsMatchFilterElementHide(pEl))
         {
 #ifdef ENABLE_DEBUG_RESULT
           DEBUG_HIDE_EL(indent + "HideEl::Found (?/id) filter:" + idIt->second.m_filterText)
-            CPluginDebug::DebugResultHiding(tagCString, "id:" + id, idIt->second.m_filterText);
+            CPluginDebug::DebugResultHiding(tag, L"id:" + ToWstring(id), ToWstring(idIt->second.m_filterText));
 #endif
           return true;
         }
       }
     }
 
     // Search tag/className filters
     if (!classNames.IsEmpty())
     {
       int pos = 0;
       CString className = classNames.Tokenize(L" \t\n\r", pos);
       while (pos >= 0)
       {
         std::pair<TFilterElementHideTagsNamed::const_iterator, TFilterElementHideTagsNamed::const_iterator> classItEnum = 
           m_elementHideTagsClass.equal_range(std::make_pair(tagCString, className));
 
         for (TFilterElementHideTagsNamed::const_iterator classIt = classItEnum.first; classIt != classItEnum.second; ++classIt)
         {
           if (classIt->second.IsMatchFilterElementHide(pEl))
           {
 #ifdef ENABLE_DEBUG_RESULT
             DEBUG_HIDE_EL(indent + "HideEl::Found (tag/class) filter:" + classIt->second.m_filterText)
-              CPluginDebug::DebugResultHiding(tagCString, "class:" + className, classIt->second.m_filterText);
+              CPluginDebug::DebugResultHiding(tag, L"class:" + ToWstring(className), ToWstring(classIt->second.m_filterText));
 #endif
             return true;
           }
         }
 
         // Search general class name
         classItEnum = m_elementHideTagsClass.equal_range(std::make_pair("", className));
         for (TFilterElementHideTagsNamed::const_iterator classIt = classItEnum.first; classIt != classItEnum.second; ++ classIt)
         {
           if (classIt->second.IsMatchFilterElementHide(pEl))
           {
 #ifdef ENABLE_DEBUG_RESULT
-            DEBUG_HIDE_EL(indent + "HideEl::Found (?/class) filter:" + classIt->second.m_filterText)
-              CPluginDebug::DebugResultHiding(tagCString, "class:" + className, classIt->second.m_filterText);
+            DEBUG_HIDE_EL(indent + L"HideEl::Found (?/class) filter:" + ToWString(classIt->second.m_filterText));
+            CPluginDebug::DebugResultHiding(tag, L"class:" + ToWstring(className), ToWstring(classIt->second.m_filterText));
 #endif
             return true;
           }
         }
 
         // Next class name
         className = classNames.Tokenize(L" \t\n\r", pos);
       }
     }
 
     // Search tag filters
     std::pair<TFilterElementHideTags::const_iterator, TFilterElementHideTags::const_iterator> tagItEnum 
       = m_elementHideTags.equal_range(tagCString);
     for (TFilterElementHideTags::const_iterator tagIt = tagItEnum.first; tagIt != tagItEnum.second; ++ tagIt)
     {
       if (tagIt->second.IsMatchFilterElementHide(pEl))
       {
 #ifdef ENABLE_DEBUG_RESULT
         DEBUG_HIDE_EL(indent + "HideEl::Found (tag) filter:" + tagIt->second.m_filterText)
-          CPluginDebug::DebugResultHiding(tagCString, "-", tagIt->second.m_filterText);
+          CPluginDebug::DebugResultHiding(tag, L"-", ToWstring(tagIt->second.m_filterText));
 #endif
         return true;
       }
     }
   }
 
   return false;
 }
 
-bool CPluginFilter::LoadHideFilters(const std::vector<std::wstring>& filters)
-{
-  ClearFilters();
+CPluginFilter::CPluginFilter(const std::vector<std::wstring>& filters)
+{
   m_hideFilters = filters;
-  bool isRead = false;
   CPluginClient* client = CPluginClient::GetInstance();
 
   // Parse hide string
   int pos = 0;
   CriticalSection::Lock filterEngineLock(s_criticalSectionFilterMap);
   {
-    for (std::vector<std::wstring>::const_iterator it = filters.begin(); it < filters.end(); ++it)
+    for (auto it = filters.begin(); it < filters.end(); ++it)
     {
       CString filter((*it).c_str());
       // If the line is not commented out
       if (!filter.Trim().IsEmpty() && filter.GetAt(0) != '!' && filter.GetAt(0) != '[')
       {
         int filterType = 0;
 
         // See http://adblockplus.org/en/filters for further documentation
 
         try
         {
           AddFilterElementHide(filter);
         }
         catch(...)
         {
 #ifdef ENABLE_DEBUG_RESULT
-          CPluginDebug::DebugResult(L"Error loading hide filter: " + filter);
+          CPluginDebug::DebugResult(L"Error loading hide filter: " + ToWstring(filter));
 #endif
         }
       }
     }
   }
-
-  return isRead;
-}
-
-void CPluginFilter::ClearFilters()
-{
-  // Clear filter maps
-  CriticalSection::Lock filterEngineLock(s_criticalSectionFilterMap);
-  {
-    for (int i = 0; i < 2; i++)
-    {
-      for (int j = 0; j < 2; j++)
-      {
-        m_filterMap[i][j].clear();
-      }
-      m_filterMapDefault[i].clear();
-    }
-
-    m_elementHideTags.clear();
-    m_elementHideTagsId.clear();
-    m_elementHideTagsClass.clear();
-    m_hideFilters.clear();
-  }
-}
-
-bool CPluginFilter::ShouldBlock(const std::wstring& src, int contentType, const std::wstring& domain, bool addDebug) const
-{
-  CString srcCString = to_CString(src);
-
-  // We should not block the empty string, so all filtering does not make sense
-  // Therefore we just return
-  if (srcCString.Trim().IsEmpty())
-  {
-    return false;
-  }
-
-  CPluginSettings* settings = CPluginSettings::GetInstance();
-
-  CString type;
-  if (addDebug)
-  {
-    type = "OTHER";
-
-    std::map<int,CString>::const_iterator it = m_contentMapText.find(contentType);
-    if (it != m_contentMapText.end())
-    {
-      type = it->second;
-    }
-  }
-
-  CPluginClient* client = CPluginClient::GetInstance();
-  if (client->Matches(to_wstring(srcCString), to_wstring(type), domain))
-  {
-    if (addDebug)
-    {
-      DEBUG_FILTER("Filter::ShouldBlock " + type + " YES")
-
-#ifdef ENABLE_DEBUG_RESULT
-        CPluginDebug::DebugResultBlocking(type, srcCString, domain);
-#endif
-    }
-    return true;
-  }
-#ifdef ENABLE_DEBUG_RESULT
-  CPluginDebug::DebugResultIgnoring(type, srcCString, domain);
-#endif
-  return false;
-}
-
-const std::vector<std::wstring>& CPluginFilter::getHideFilters() const
-{
-  DWORD res = WaitForSingleObject(hideFiltersLoadedEvent, ENGINE_STARTUP_TIMEOUT);

[Oleksandr, 2015/02/04 20:59:57]

It's hard to understand this from the scattered reviews, I just don't see it.
Where do we set this event?

[sergei, 2015/04/13 08:06:58]

`hideFiltersLoadedEvent` is not introduced in these changes, It's set in
PluginTabBase.cpp in `FilterLoader`. JIC, I'm sure that refactoring of
`hideFiltersLoadedEvent` should not be a part of this issue.

-  return m_hideFilters;
 }