Issue #1234 - Convert strings associated with URL's

src/plugin/PluginFilter.cpp

 #include "PluginStdAfx.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"
 
 
 // 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 236 matching lines @@
       }
       if (!foundMatch)
       {
         return false;
       }
     }
   }
   if (!m_tag.IsEmpty())
   {
     CComBSTR tagName;
+    hr = pEl->get_tagName(&tagName);
     tagName.ToLower();
-    hr = pEl->get_tagName(&tagName);
     if ((hr != S_OK) || (tagName != CComBSTR(m_tag)))
     {
       return false;
     }
   }
 
   // Check attributes
   for (std::vector<CFilterElementHideAttrSelector>::const_iterator attrIt = m_attributeSelectors.begin(); 
         attrIt != m_attributeSelectors.end(); ++ attrIt)
   {
-    CString value;
+    ATL::CString value;
     bool attrFound = false;
     if (attrIt->m_type == CFilterElementHideAttrType::STYLE)
     {
       CComPtr<IHTMLStyle> pStyle;
       if (SUCCEEDED(pEl->get_style(&pStyle)) && pStyle)
       {
         CComBSTR bstrStyle;
 
         if (SUCCEEDED(pStyle->get_cssText(&bstrStyle)) && bstrStyle)
         {
@@ skipping 14 matching lines @@
     }
     else if (attrIt->m_type == CFilterElementHideAttrType::ID)
     {
       CComBSTR bstrId;
       if (SUCCEEDED(pEl->get_id(&bstrId)) && bstrId)
       {
         value = bstrId;
         attrFound = true;
       }
     }
-    else 
-    {
-      CComVariant vAttr;
-      if (SUCCEEDED(pEl->getAttribute(attrIt->m_bstrAttr, 0, &vAttr)))
-      {
-        attrFound = true;
-        if (vAttr.vt == VT_BSTR)
-        {
-          value = vAttr.bstrVal;
-        }
-        else if (vAttr.vt == VT_I4)
-        {
-          value.Format(L"%u", vAttr.iVal);
-        }
+    else
+    {
+      auto attributeValue = GetHtmlElementAttribute(*pEl, attrIt->m_bstrAttr);
+      if (attrFound = attributeValue.isAttributeFound)
+      {
+        value = ToCString(attributeValue.attributeValue);
       }
     }
 
     if (attrFound)
     {
       if (attrIt->m_pos == CFilterElementHideAttrPos::EXACT)
       {
         // TODO: IE rearranges the style attribute completely. Figure out if anything can be done about it.
         if (value != attrIt->m_value)
           return false;
@@ skipping 67 matching lines @@
 
 
 // ============================================================================
 // 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::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);    
-  {
-
+  CriticalSection::Lock filterEngineLock(s_criticalSectionFilterMap);
+  {
     CString filterString  = filterText;
     // Create filter descriptor
     std::auto_ptr<CFilterElementHide> filter;
 
     CString wholeFilterString = filterString;
     wchar_t separatorChar;
     do
     {
       int chunkEnd = filterText.FindOneOf(L"+>");
       if (chunkEnd > 0)
       {
         separatorChar = filterText.GetAt(chunkEnd);
       }
       else
       {
         chunkEnd = filterText.GetLength();
         separatorChar = L'\0';
       }
 
       CString filterChunk = filterText.Left(chunkEnd).TrimRight();
       std::auto_ptr<CFilterElementHide> filterParent(filter);
 
-      filter.reset(new CFilterElementHide(filterChunk));       
+      filter.reset(new CFilterElementHide(filterChunk));
 
       if (filterParent.get() != 0)
       {
         filter->m_predecessor.reset(filterParent.release());
       }
 
       if (separatorChar != L'\0') // complex selector
       {
         filterText = filterText.Mid(chunkEnd + 1).TrimLeft();
         if (separatorChar == '+')
@@ skipping 34 matching lines @@
     id = bstrId;
   }
 
   CString classNames;
   CComBSTR bstrClassNames;
   if (SUCCEEDED(pEl->get_className(&bstrClassNames)) && bstrClassNames)
   {
     classNames = bstrClassNames;
   }
 
-  CriticalSection::Lock filterEngineLock(s_criticalSectionFilterMap);    
+  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))
         {
@@ skipping 81 matching lines @@
 }
 
 bool CPluginFilter::LoadHideFilters(std::vector<std::wstring> filters)
 {
   ClearFilters();
   bool isRead = false;
   CPluginClient* client = CPluginClient::GetInstance();
 
   // Parse hide string
   int pos = 0;
-  CriticalSection::Lock filterEngineLock(s_criticalSectionFilterMap);    
+  CriticalSection::Lock filterEngineLock(s_criticalSectionFilterMap);
   {
     for (std::vector<std::wstring>::iterator 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
@@ skipping 11 matching lines @@
       }
     }
   }
 
   return isRead;
 }
 
 void CPluginFilter::ClearFilters()
 {
   // Clear filter maps
-  CriticalSection::Lock filterEngineLock(s_criticalSectionFilterMap);    
+  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();
   }
 }
 
 bool CPluginFilter::ShouldBlock(const std::wstring& src, int contentType, const std::wstring& domain, bool addDebug) const
 {
-  CString srcCString = ToCString(src);
-  srcCString.Trim();

[Oleksandr, 2015/01/05 11:55:40]

We have TrimString function in shared/Utils.h for this.

[Eric, 2015/01/05 16:18:26]

Done.

-  std::wstring srcTrimmed = ToWstring(srcCString);
+  std::wstring srcTrimmed = TrimString(src);
 
   // We should not block the empty string, so all filtering does not make sense
   // Therefore we just return
   if (srcTrimmed.empty())
   {
     return false;
   }
   CPluginSettings* settings = CPluginSettings::GetInstance();
 
   CString type;
@@ skipping 15 matching lines @@
     {
       DEBUG_FILTER("Filter::ShouldBlock " + type + " YES")
 
 #ifdef ENABLE_DEBUG_RESULT
         CPluginDebug::DebugResultBlocking(type, srcTrimmed, domain);
 #endif
     }
     return true;
   }
 #ifdef ENABLE_DEBUG_RESULT
-  CPluginDebug::DebugResultIgnoring(type, src, domain);
+  CPluginDebug::DebugResultIgnoring(type, srcTrimmed, domain);
 #endif
   return false;
 }