Issue #41 - Bring method of determining IE version up to date

src/plugin/AdblockPlusClient.cpp

 #include "PluginStdAfx.h"
 #include "PluginSettings.h"
 #include "PluginSystem.h"
 #include "PluginFilter.h"
 #include "PluginClientFactory.h"
 #include "PluginMutex.h"
 #include "PluginClass.h"
 
 #include "AdblockPlusClient.h"
 
 #include "../shared/Utils.h"
 
 namespace
 {
   void SpawnAdblockPlusEngine()
   {
     std::wstring engineExecutablePath = GetDllDir() + L"AdblockPlusEngine.exe";
-    CString params = L"AdblockPlusEngine.exe " + CPluginSystem::GetInstance()->GetBrowserLanguage();
+    CString params = to_CString(L"AdblockPlusEngine.exe " + GetBrowserLanguage());
 
     STARTUPINFO startupInfo = {};
     PROCESS_INFORMATION processInformation = {};
 
     HANDLE token;
     OpenProcessToken(GetCurrentProcess(), TOKEN_DUPLICATE | TOKEN_ADJUST_DEFAULT | TOKEN_QUERY | TOKEN_ASSIGN_PRIMARY, &token);
 
     TOKEN_APPCONTAINER_INFORMATION *acs = NULL;
     DWORD length = 0;
 
@@ skipping 28 matching lines @@
 
       PSID integritySid = 0;
       ConvertStringSidToSid(L"S-1-16-4096", &integritySid);
       std::tr1::shared_ptr<SID> sharedIntegritySid(static_cast<SID*>(integritySid), FreeSid); // Just to simplify cleanup
 
       TOKEN_MANDATORY_LABEL tml = {};
       tml.Label.Attributes = SE_GROUP_INTEGRITY;
       tml.Label.Sid = integritySid;
 
       // Set the process integrity level
-      SetTokenInformation(newToken, TokenIntegrityLevel, &tml, sizeof(TOKEN_MANDATORY_LABEL) + GetLengthSid(integritySid));
+      SetTokenInformation(newToken, TokenIntegrityLevel, &tml, sizeof(tml));
 
       STARTUPINFO startupInfo = {};
       PROCESS_INFORMATION processInformation = {};
 
       createProcRes = CreateProcessAsUserW(newToken, engineExecutablePath.c_str(), params.GetBuffer(params.GetLength() + 1),
                               0, 0, false, 0, 0, 0, (STARTUPINFOW*)&startupInfo, &processInformation);
     }
 
     if (!createProcRes)
     {
@@ skipping 123 matching lines @@
       s_instance = client;
     }
 
     instance = s_instance;
   }
   s_criticalSectionLocal.Unlock();
 
   return instance;
 }
 
-
-bool CAdblockPlusClient::ShouldBlock(CString src, int contentType, const CString& domain, bool addDebug)
+bool CAdblockPlusClient::ShouldBlock(const std::wstring& src, int contentType, const std::wstring& domain, bool addDebug)
 {
   bool isBlocked = false;
-
   bool isCached = false;
-
-  CPluginSettings* settings = CPluginSettings::GetInstance();
-
   m_criticalSectionCache.Lock();
   {
-    std::map<CString,bool>::iterator it = m_cacheBlockedSources.find(src);
+    auto it = m_cacheBlockedSources.find(src);
 
     isCached = it != m_cacheBlockedSources.end();
     if (isCached)
     {
       isBlocked = it->second;
     }
   }
   m_criticalSectionCache.Unlock();
 
   if (!isCached)
   {
     m_criticalSectionFilter.Lock();
     {
       isBlocked = m_filter->ShouldBlock(src, contentType, domain, addDebug);
     }
     m_criticalSectionFilter.Unlock();
-
 
     // Cache result, if content type is defined
     if (contentType != CFilter::contentTypeAny)
     {
       m_criticalSectionCache.Lock();
       {
         m_cacheBlockedSources[src] = isBlocked;
       }
       m_criticalSectionCache.Unlock();
     }
   }
-
-
   return isBlocked;
 }
 
-bool CAdblockPlusClient::IsElementHidden(const CString& tag, IHTMLElement* pEl, const CString& domain, const CString& indent, CPluginFilter* filter)
+bool CAdblockPlusClient::IsElementHidden(const std::wstring& tag, IHTMLElement* pEl, const std::wstring& domain, const std::wstring& indent, CPluginFilter* filter)
 {
   bool isHidden;
   m_criticalSectionFilter.Lock();
   {
     isHidden = filter && filter->IsElementHidden(tag, pEl, domain, indent);
   }
   m_criticalSectionFilter.Unlock();
   return isHidden;
 }
 
 bool CAdblockPlusClient::IsWhitelistedUrl(const std::wstring& url)
 {
   DEBUG_GENERAL((L"IsWhitelistedUrl: " + url + L" start").c_str());
   Communication::OutputBuffer request;
   request << Communication::PROC_IS_WHITELISTED_URL << ToUtf8String(url);
 
   Communication::InputBuffer response;
   if (!CallEngine(request, response)) 
     return false;
 
   bool isWhitelisted;
   response >> isWhitelisted;
 
   DEBUG_GENERAL((L"IsWhitelistedUrl: " + url + L" end").c_str());
+  return isWhitelisted;
+}
+
+bool CAdblockPlusClient::IsElemhideWhitelistedOnDomain(const std::wstring& url)
+{
+  Communication::OutputBuffer request;
+  request << Communication::PROC_IS_ELEMHIDE_WHITELISTED_ON_URL << ToUtf8String(url);
+
+  Communication::InputBuffer response;
+  if (!CallEngine(request, response)) 
+    return false;
+
+  bool isWhitelisted;
+  response >> isWhitelisted;
   return isWhitelisted;
 }
 
 bool CAdblockPlusClient::Matches(const std::wstring& url, const std::wstring& contentType, const std::wstring& domain)
 {
   Communication::OutputBuffer request;
   request << Communication::PROC_MATCHES << ToUtf8String(url) << ToUtf8String(contentType) << ToUtf8String(domain);
 
   Communication::InputBuffer response;
   if (!CallEngine(request, response)) 
@@ skipping 83 matching lines @@
 
 bool CAdblockPlusClient::IsFirstRun()
 {
   DEBUG_GENERAL("IsFirstRun");
   Communication::InputBuffer response;
   if (!CallEngine(Communication::PROC_IS_FIRST_RUN_ACTION_NEEDED, response)) return false;
   bool res;
   response >> res;
   return res;
 }
+
 void CAdblockPlusClient::AddFilter(const std::wstring& text)
 {
   Communication::OutputBuffer request;
   request << Communication::PROC_ADD_FILTER << ToUtf8String(text);
   CallEngine(request);
 }
 
 void CAdblockPlusClient::RemoveFilter(const std::wstring& text)
 {
   Communication::OutputBuffer request;
@@ skipping 135 matching lines @@
   Communication::OutputBuffer request;
   request << Communication::PROC_GET_HOST << ToUtf8String(url);
 
   Communication::InputBuffer response;
   if (!CallEngine(request, response)) 
     return L"";
   std::string host;
   response >> host;
   return ToUtf16String(host);
 }
+
+int CAdblockPlusClient::CompareVersions(const std::wstring& v1, const std::wstring& v2)
+{
+  DEBUG_GENERAL("CompareVersions");
+  Communication::OutputBuffer request;
+  request << Communication::PROC_COMPARE_VERSIONS << ToUtf8String(v1) << ToUtf8String(v2);
+  Communication::InputBuffer response;
+  if (!CallEngine(request, response))
+    return 0;
+  int result;
+  response >> result;
+  return result;
+}