Hanging resolved (critical sections unlocking)

src/plugin/PluginFilter.cpp

 #include "PluginStdAfx.h"
 
 #include "PluginFilter.h"
 
 #if (defined PRODUCT_ADBLOCKPLUS)
 #include "PluginSettings.h"
 #include "PluginClient.h"
 #include "PluginClientFactory.h"
 #endif
 
 #include "PluginMutex.h"
 #include "PluginHttpRequest.h"
 #include "PluginSettings.h"
 #include "PluginSystem.h"
 #include "PluginClass.h"
 #include "mlang.h"
 
+#include "..\shared\CriticalSection.h"
+
 
 // The filters are described at http://adblockplus.org/en/filters
 
-CComAutoCriticalSection CPluginFilter::s_criticalSectionFilterMap;
-
+static CriticalSection s_criticalSectionFilterMap;
 
 // ============================================================================
 // CFilterElementHideAttrSelector
 // ============================================================================
 
 CFilterElementHideAttrSelector::CFilterElementHideAttrSelector() : m_type(TYPE_NONE), m_pos(POS_NONE), m_bstrAttr(NULL)
 {
 }
 
 CFilterElementHideAttrSelector::CFilterElementHideAttrSelector(const CFilterElementHideAttrSelector& filter)
@@ skipping 386 matching lines @@
 }
 
 
 
 // ============================================================================
 // CPluginFilter
 // ============================================================================
 
 CPluginFilter::CPluginFilter(const CString& dataPath) : m_dataPath(dataPath)
 {
-  m_contentMap["document"] = CFilter::contentTypeDocument;
-  m_contentMap["subdocument"] = CFilter::contentTypeSubdocument;
-  m_contentMap["sub-document"] = CFilter::contentTypeSubdocument;
-  m_contentMap["sub_document"] = CFilter::contentTypeSubdocument;
-  m_contentMap["other"] = CFilter::contentTypeOther;
-  m_contentMap["image"] = CFilter::contentTypeImage;
-  m_contentMap["script"] = CFilter::contentTypeScript;
-  m_contentMap["object"] = CFilter::contentTypeObject;
-  m_contentMap["object-subrequest"] = CFilter::contentTypeObjectSubrequest;
-  m_contentMap["object_subrequest"] = CFilter::contentTypeObjectSubrequest;
-  m_contentMap["xml-request"] = CFilter::contentTypeXmlHttpRequest;
-  m_contentMap["xml_request"] = CFilter::contentTypeXmlHttpRequest;
-  m_contentMap["xmlhttprequest"] = CFilter::contentTypeXmlHttpRequest;
-  m_contentMap["stylesheet"] = CFilter::contentTypeStyleSheet;
-  m_contentMap["background"] = CFilter::contentTypeBackground;
-
   m_contentMapText[CFilter::contentTypeDocument] = "DOCUMENT";
   m_contentMapText[CFilter::contentTypeObject] = "OBJECT";
   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);
 
-  s_criticalSectionFilterMap.Lock();    
+  CriticalSection::Lock filterEngineLock(s_criticalSectionFilterMap);    
   {
 
     CString filterString  = filterText;
     // Create filter descriptor
     std::auto_ptr<CFilterElementHide> filter;
 
     CString wholeFilterString = filterString;
     TCHAR separatorChar;
     do
     {
@@ skipping 37 matching lines @@
           m_elementHideTagsClass.insert(std::make_pair(std::make_pair(filter->m_tag, filter->m_tagClassName), *filter));
         }
         else
         {
           std::pair<CString, CFilterElementHide> pair = std::make_pair(filter->m_tag, *filter);
           m_elementHideTags.insert(pair);
         }
       }
     } while (separatorChar != '\0');
   }
-  s_criticalSectionFilterMap.Unlock();    
 
   return true;
 }
 
 bool CPluginFilter::IsElementHidden(const CString& tag, IHTMLElement* pEl, const CString& domain, const CString& indent) const
 {
   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;
   }
 
-  s_criticalSectionFilterMap.Lock();
+  CriticalSection::Lock filterEngineLock(s_criticalSectionFilterMap);    
   {
     CString domainTest = domain;
 
     // Search tag/id filters
     if (!id.IsEmpty())
     {
       std::pair<TFilterElementHideTagsNamed::const_iterator, TFilterElementHideTagsNamed::const_iterator> idItEnum =
         m_elementHideTagsId.equal_range(std::make_pair(tag, 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(tag, "id:" + id, idIt->second.m_filterText);
 #endif
-          s_criticalSectionFilterMap.Unlock();
           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(tag, "id:" + id, idIt->second.m_filterText);
 #endif
-          s_criticalSectionFilterMap.Unlock();
           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(tag, 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(tag, "class:" + className, classIt->second.m_filterText);
 #endif
-            s_criticalSectionFilterMap.Unlock();
             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(tag, "class:" + className, classIt->second.m_filterText);
 #endif
-            s_criticalSectionFilterMap.Unlock();
             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(tag);
     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(tag, "-", tagIt->second.m_filterText);
 #endif
-        s_criticalSectionFilterMap.Unlock();
         return true;
       }
     }
   }
-  s_criticalSectionFilterMap.Unlock();
 
   return false;
 }
 
 bool CPluginFilter::LoadHideFilters(std::vector<std::string> filters)
 {
 
   ClearFilters();
 
   bool isRead = false;
 
 #ifdef PRODUCT_ADBLOCKPLUS
   CPluginClient* client = CPluginClient::GetInstance();
 #endif
 
   // Parse hide string
   int pos = 0;
 
-  s_criticalSectionFilterMap.Lock();
+  CriticalSection::Lock filterEngineLock(s_criticalSectionFilterMap);    
   {
     for (std::vector<std::string>::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
 
         try
         {
           AddFilterElementHide(filter);
         }
         catch(...)
         {
 #ifdef ENABLE_DEBUG_RESULT
           CPluginDebug::DebugResult(L"Error loading hide filter: " + filter);
 #endif
         }
       }
     }
   }
-  s_criticalSectionFilterMap.Unlock();
 
   return isRead;
 }
 
 void CPluginFilter::ClearFilters()
 {
   // Clear filter maps
-  s_criticalSectionFilterMap.Lock();    
+  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();
   }
-  s_criticalSectionFilterMap.Unlock();
 }
 
 
 bool CPluginFilter::ShouldWhiteList(CString src) const
 {
   // We should not block the empty string, so all filtering does not make sense
   // Therefore we just return
   if (src.Trim().IsEmpty())
   {
     return false;
@@ skipping 36 matching lines @@
 
   std::string domainMb = CT2CA(domain);
 
   if (client->Matches(url, contentTypeString, domainMb))
   {
     if (addDebug)
     {
       DEBUG_FILTER("Filter::ShouldBlock " + type + " YES")
 
 #ifdef ENABLE_DEBUG_RESULT
-        CPluginDebug::DebugResultBlocking(type, src);
+        CPluginDebug::DebugResultBlocking(type, src, domain);
 #endif
     }
     return true;
   }
   return false;
 }
 
 int CPluginFilter::FindMatch(const CString& src, CString filterPart, int srcStartPos) const
 {
   int filterCurrentPos = filterPart.Find('^');
@@ skipping 138 matching lines @@
   if (pos > 0 && domain.GetLength() + pos == subdomain.GetLength())
   {
     if (subdomain.GetAt(pos - 1) == '.')
     {
       return true;
     }
   }
 
   return false;
 }