Issue 3237 - Whitelisted AFS ad is not shown on netzwelt.de

src/plugin/PluginDomTraverserBase.h

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2015 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 31 matching lines @@
 
   void TraverseHeader(bool isHeaderTraversed);
 
   void TraverseDocument(IWebBrowser2* pBrowser, const std::wstring& domain, const std::wstring& documentUrl);
   void TraverseSubdocument(IWebBrowser2* pBrowser, const std::wstring& domain, const std::wstring& documentUrl);
 
   virtual void ClearCache();
 
 protected:
 
-  virtual bool OnIFrame(IHTMLElement* pEl, const std::wstring& url, CString& indent) { return true; }
-  virtual bool OnElement(IHTMLElement* pEl, const CString& tag, T* cache, bool isDebug, CString& indent) { return true; }
+  virtual bool OnIFrame(IHTMLElement* pEl, const std::wstring& url, const std::wstring& indent) { return true; }
+  virtual bool OnElement(IHTMLElement* pEl, const std::wstring& tag, T* cache, bool isDebug, const std::wstring& indent) { return true; }
 
   virtual bool IsEnabled();
 
 protected:
 
-  void TraverseDocument(IWebBrowser2* pBrowser, bool isMainDoc, CString indent);
-  void TraverseChild(IHTMLElement* pEl, IWebBrowser2* pBrowser, CString& indent, bool isCached=true);
+  void TraverseDocument(IWebBrowser2* pBrowser, bool isMainDoc, const std::wstring& indent);
+  void TraverseChild(IHTMLElement* pEl, IWebBrowser2* pBrowser, const std::wstring& indent, bool isCached=true);
 
   CComAutoCriticalSection m_criticalSection;
 
   std::wstring m_domain;
   std::wstring m_documentUrl;
 
   bool m_isHeaderTraversed;
 
   // Caching    
   long m_cacheDomElementCount;
@@ skipping 27 matching lines @@
 void CPluginDomTraverserBase<T>::TraverseHeader(bool isHeaderTraversed)
 {
   m_isHeaderTraversed = isHeaderTraversed;
 }
 
 template <class T>
 void CPluginDomTraverserBase<T>::TraverseDocument(IWebBrowser2* pBrowser, const std::wstring& domain, const std::wstring& documentUrl)
 {
   m_domain = domain;
   m_documentUrl = documentUrl;
-  TraverseDocument(pBrowser, true, "");
+  TraverseDocument(pBrowser, true, L"");
 }
 
 
 template <class T>
 void CPluginDomTraverserBase<T>::TraverseSubdocument(IWebBrowser2* pBrowser, const std::wstring& domain, const std::wstring& documentUrl)
 {
   m_domain = domain;
   m_documentUrl = documentUrl;
-  TraverseDocument(pBrowser, false, "");
+  TraverseDocument(pBrowser, false, L"");
 }
 
 
 template <class T>
 bool CPluginDomTraverserBase<T>::IsEnabled()
 {
   return CPluginSettings::GetInstance()->IsPluginEnabled();
 }
 
 
 template <class T>
-void CPluginDomTraverserBase<T>::TraverseDocument(IWebBrowser2* pBrowser, bool isMainDoc, CString indent)
+void CPluginDomTraverserBase<T>::TraverseDocument(IWebBrowser2* pBrowser, bool isMainDoc, const std::wstring& indent)
 {
   DWORD res = WaitForSingleObject(m_tab->m_filter->hideFiltersLoadedEvent, ENGINE_STARTUP_TIMEOUT);
   if (!IsEnabled()) return;
 
   VARIANT_BOOL isBusy;
   if (SUCCEEDED(pBrowser->get_Busy(&isBusy)))
   {
     if (isBusy != VARIANT_FALSE)
     {
       return;
@@ skipping 34 matching lines @@
       return;
     }
 
     CComVariant vIndex(0);
     CComPtr<IDispatch> pBodyDispatch;
     if (FAILED(pBodyCollection->item(vIndex, vIndex, &pBodyDispatch)) || !pBodyDispatch)
     {
       return;
     }
 
-    if (FAILED(pBodyDispatch->QueryInterface(IID_IHTMLElement, (LPVOID*)&pBodyEl)) || !pBodyEl)
+    if (FAILED(pBodyDispatch->QueryInterface(&pBodyEl)) || !pBodyEl)
     {
       return;
     }
   }
 
   // Clear cache (if eg. refreshing) ???
   if (isMainDoc)
   {
     CComVariant vCacheIndex;
 
@@ skipping 104 matching lines @@
                 TraverseDocument(pFrameBrowser, false, indent);
               }
             }
           }
         }
       }
     }
   }
 }
 
-
-template <class T>
-void CPluginDomTraverserBase<T>::TraverseChild(IHTMLElement* pEl, IWebBrowser2* pBrowser, CString& indent, bool isCached)
+template <class T>
+void CPluginDomTraverserBase<T>::TraverseChild(IHTMLElement* pEl, IWebBrowser2* pBrowser, const std::wstring& indent, bool isCached)
 {
   int  cacheIndex = -1;
   long cacheAllElementsCount = -1;
 
   m_criticalSection.Lock();
   {
     CComVariant vCacheIndex;
     if (isCached && SUCCEEDED(pEl->getAttribute(ATL::CComBSTR(L"abp"), 0, &vCacheIndex)) && vCacheIndex.vt == VT_I4)
     {
       cacheIndex = vCacheIndex.intVal;
@@ skipping 32 matching lines @@
 
   // Get number of elements in the scope of pEl
   long allElementsCount = 0;
 
   CComPtr<IDispatch> pAllCollectionDisp;
 
   if (SUCCEEDED(pEl->get_all(&pAllCollectionDisp)) && pAllCollectionDisp)
   {
     CComPtr<IHTMLElementCollection> pAllCollection;
 
-    if (SUCCEEDED(pAllCollectionDisp->QueryInterface(IID_IHTMLElementCollection, (LPVOID*)&pAllCollection)) && pAllCollection)
+    if (SUCCEEDED(pAllCollectionDisp->QueryInterface(&pAllCollection)) && pAllCollection)
     {
       // If number of elements = cached number, return
       if (SUCCEEDED(pAllCollection->get_length(&allElementsCount)) && allElementsCount == cacheAllElementsCount)
       {
         return;
       }
     }
   }
 
   // Update cache
   m_criticalSection.Lock();
   {
     m_cacheElements[cacheIndex].m_elements = allElementsCount;
   }
   m_criticalSection.Unlock();
 
   // Get tag
   CComBSTR bstrTag;
   if (FAILED(pEl->get_tagName(&bstrTag)) || !bstrTag)
   {
     return;
   }
-
-  CString tag = bstrTag;
-  tag.MakeLower();
+  std::wstring tag = ToLowerString(ToWstring(bstrTag));
 
   // Custom OnElement
   if (!OnElement(pEl, tag, &m_cacheElements[cacheIndex], false, indent))
   {
     return;
   }
 
   // Update frame/iframe cache
-  if (tag == "iframe")
+  if (tag == L"iframe")
   {
     m_criticalSection.Lock();
     {
       m_cacheDocumentHasIframes.insert(m_documentUrl);
     }
     m_criticalSection.Unlock();
   }
-  else if (tag == "frame")
+  else if (tag == L"frame")
   {
     m_criticalSection.Lock();
     {
       m_cacheDocumentHasFrames.insert(m_documentUrl);
     }
     m_criticalSection.Unlock();
   }
 
   // Iterate through children of this element
   if (allElementsCount > 0)
   {
     long childElementsCount = 0;
 
     CComPtr<IDispatch> pChildCollectionDisp;
     if (SUCCEEDED(pEl->get_children(&pChildCollectionDisp)) && pChildCollectionDisp)
     {
       CComPtr<IHTMLElementCollection> pChildCollection;
-      if (SUCCEEDED(pChildCollectionDisp->QueryInterface(IID_IHTMLElementCollection, (LPVOID*)&pChildCollection)) && pChildCollection)
+      if (SUCCEEDED(pChildCollectionDisp->QueryInterface(&pChildCollection)) && pChildCollection)
       {
         pChildCollection->get_length(&childElementsCount);
 
         CComVariant vIndex(0);
 
         // Iterate through all children
         for (long i = 0; i < childElementsCount; i++)
         {
           CComPtr<IDispatch> pChildElDispatch;
           CComVariant vRetIndex;
 
           vIndex.intVal = i;
 
           if (SUCCEEDED(pChildCollection->item(vIndex, vRetIndex, &pChildElDispatch)) && pChildElDispatch)
           {
             CComPtr<IHTMLElement> pChildEl;
-            if (SUCCEEDED(pChildElDispatch->QueryInterface(IID_IHTMLElement, (LPVOID*)&pChildEl)) && pChildEl)
+            if (SUCCEEDED(pChildElDispatch->QueryInterface(&pChildEl)) && pChildEl)
             {
-              TraverseChild(pChildEl, pBrowser, indent + "  ", isCached);
+              TraverseChild(pChildEl, pBrowser, indent + L"  ", isCached);
             }
           }
         }
       }
     }
   }
 }
 
 
 template <class T>
 void CPluginDomTraverserBase<T>::ClearCache()
 {
   m_criticalSection.Lock();
   {
     m_cacheIndexLast = 0;
     m_cacheDocumentHasFrames.clear();
     m_cacheDocumentHasIframes.clear();
   }
   m_criticalSection.Unlock();
 }
 
 
 #endif // _PLUGIN_DOM_TRAVERSER_BASE_H_