Issue #2230 - Refactor filter life cycle and use

src/plugin/PluginDomTraverserBase.h

 /*
  * 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/>.
  */
 
 #ifndef _PLUGIN_DOM_TRAVERSER_BASE_H_
 #define _PLUGIN_DOM_TRAVERSER_BASE_H_
 
-#include "PluginTabBase.h"
+#include "PluginFilter.h"
 #include "PluginUtil.h"
 
 class CPluginDomTraverserCacheBase
 {
 public:
 
   long m_elements;
 
   CPluginDomTraverserCacheBase() : m_elements(0) {};
   void Init() { m_elements=0; }
 };
 
 template <class T>
 class CPluginDomTraverserBase
 {
 
 public:
 
-  CPluginDomTraverserBase(CPluginTab* tab);
+  CPluginDomTraverserBase(CPluginFilter* filterSet);
   ~CPluginDomTraverserBase();
 
-  void TraverseHeader(bool isHeaderTraversed);
-
-  void TraverseDocument(IWebBrowser2* pBrowser, const std::wstring& domain, const std::wstring& documentUrl);
+  void TraverseDocumentRoot(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, 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, const std::wstring& indent);
+  void TraverseDocument(IWebBrowser2* pBrowser, 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;
-
   int m_cacheIndexLast;
   int m_cacheElementsMax;
   std::set<std::wstring> m_cacheDocumentHasFrames;
   std::set<std::wstring> m_cacheDocumentHasIframes;
 
   T* m_cacheElements;
 
-  CPluginTab* m_tab;
-  CComPtr<IWebBrowser2> m_pBrowser;
+  CPluginFilter* filterSet;
 };
 
 template <class T>
-CPluginDomTraverserBase<T>::CPluginDomTraverserBase(CPluginTab* tab) : 
-  m_tab(tab), m_isHeaderTraversed(false), m_cacheDomElementCount(0), m_cacheIndexLast(0), m_cacheElementsMax(5000)
+CPluginDomTraverserBase<T>::CPluginDomTraverserBase(CPluginFilter* filterSet) : 
+  filterSet(filterSet), m_cacheIndexLast(0), m_cacheElementsMax(5000)
 {
   m_cacheElements = new T[m_cacheElementsMax];
 }
 
 
 template <class T>
 CPluginDomTraverserBase<T>::~CPluginDomTraverserBase()
 {
   delete [] m_cacheElements;
 }
 
 template <class T>
-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)
+void CPluginDomTraverserBase<T>::TraverseDocumentRoot(IWebBrowser2* pBrowser, const std::wstring& domain, const std::wstring& documentUrl)
 {
   m_domain = domain;
   m_documentUrl = documentUrl;
-  TraverseDocument(pBrowser, true, L"");
+  TraverseDocument(pBrowser, 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, L"");
-}
-
-
 template <class T>
 bool CPluginDomTraverserBase<T>::IsEnabled()
 {
   return CPluginSettings::GetInstance()->IsPluginEnabled();
 }
 
 
 template <class T>
-void CPluginDomTraverserBase<T>::TraverseDocument(IWebBrowser2* pBrowser, bool isMainDoc, const std::wstring& indent)
+void CPluginDomTraverserBase<T>::TraverseDocument(IWebBrowser2* pBrowser, const std::wstring& indent)
 {
-  DWORD res = WaitForSingleObject(m_tab->m_filter.hideFiltersLoadedEvent, ENGINE_STARTUP_TIMEOUT);
+  DWORD res = WaitForSingleObject(filterSet->hideFiltersLoadedEvent, ENGINE_STARTUP_TIMEOUT);
   if (!IsEnabled()) return;
 
   VARIANT_BOOL isBusy;
   if (SUCCEEDED(pBrowser->get_Busy(&isBusy)))
   {
     if (isBusy != VARIANT_FALSE)
     {
       return;
     }
   }
@@ skipping 12 matching lines @@
     return;
   }
 
   CComPtr<IHTMLElement> pBody;
   if (FAILED(pDoc->get_documentElement(&pBody)) || !pBody)
   {
     return;
   }
 
   CComPtr<IHTMLElement> pBodyEl;
-
-  if (m_isHeaderTraversed)
+  CComPtr<IHTMLElementCollection> pBodyCollection;
+  if (FAILED(pDoc->getElementsByTagName(ATL::CComBSTR(L"body"), &pBodyCollection)) || !pBodyCollection)
   {
-    pBodyEl = pBody;
-  }
-  else
-  {
-    CComPtr<IHTMLElementCollection> pBodyCollection;
-    if (FAILED(pDoc->getElementsByTagName(ATL::CComBSTR(L"body"), &pBodyCollection)) || !pBodyCollection)
-    {
-      return;
-    }
-
-    CComVariant vIndex(0);
-    CComPtr<IDispatch> pBodyDispatch;
-    if (FAILED(pBodyCollection->item(vIndex, vIndex, &pBodyDispatch)) || !pBodyDispatch)
-    {
-      return;
-    }
-
-    if (FAILED(pBodyDispatch->QueryInterface(&pBodyEl)) || !pBodyEl)
-    {
-      return;
-    }
+    return;
   }
 
-  // Clear cache (if eg. refreshing) ???
-  if (isMainDoc)
+  CComVariant vIndex(0);
+  CComPtr<IDispatch> pBodyDispatch;
+  if (FAILED(pBodyCollection->item(vIndex, vIndex, &pBodyDispatch)) || !pBodyDispatch)
   {
-    CComVariant vCacheIndex;
+    return;
+  }
 
-    if (FAILED(pBodyEl->getAttribute(ATL::CComBSTR(L"abp"), 0, &vCacheIndex)) || vCacheIndex.vt == VT_NULL)
-    {
-      ClearCache();
-    }
+  if (FAILED(pBodyDispatch->QueryInterface(&pBodyEl)) || !pBodyEl)
+  {
+    return;
   }
 
   // Hide elements in body part
   TraverseChild(pBodyEl, pBrowser, indent);
 
   // Check frames and iframes
   bool hasFrames = false;
   bool hasIframes = false;
 
   m_criticalSection.Lock();
@@ skipping 27 matching lines @@
         if (pFrameBrowser)
         {
           std::wstring src;
           CComBSTR bstrSrc;
           if (SUCCEEDED(pFrameBrowser->get_LocationURL(&bstrSrc)))
           {
             src = ToWstring(bstrSrc);
           }
           if (!src.empty())
           {
-            TraverseDocument(pFrameBrowser, false, indent);
+            TraverseDocument(pFrameBrowser, indent);
           }
         }
       }
     }
   }
 
   // Iframes
   if (hasIframes)
   {
     long frameCount = 0;
@@ skipping 33 matching lines @@
               {
                 src = L"http://" + m_domain + src;
               }
 
               // Check if Iframe should be traversed
               if (OnIFrame(pFrameEl, src, indent))
               {
                 CComQIPtr<IWebBrowser2> pFrameBrowser = pFrameDispatch;
                 if (pFrameBrowser)
                 {
-                  TraverseDocument(pFrameBrowser, false, indent);
+                TraverseDocument(pFrameBrowser, indent);
                 }
               }
             }
           }
         }
       }
     }
   }
 }
 
@@ skipping 131 matching lines @@
               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_