Don't use std::string in the plugin, convert when communicating with the engine

src/plugin/AdblockPlusClient.cpp

 #include "PluginStdAfx.h"
 
 #include "PluginSettings.h"
 #include "PluginSystem.h"
 #include "PluginFilter.h"
 #include "PluginClientFactory.h"
 #include "PluginHttpRequest.h"
 #include "PluginMutex.h"
 #include "PluginClass.h"
 
@@ skipping 48 matching lines @@
           return std::auto_ptr<Communication::Pipe>(new Communication::Pipe(Communication::pipeName, Communication::Pipe::MODE_CONNECT));
         }
         catch (Communication::PipeConnectionError e)
         {
         }
       }
       throw std::runtime_error("Unable to open Adblock Plus Engine pipe");
     }
   }
 
-  std::vector<std::string> ReadStrings(Communication::InputBuffer& message)
+  std::vector<std::wstring> ReadStrings(Communication::InputBuffer& message)
   {
     int32_t count;
     message >> count;
 
-    std::vector<std::string> result;
+    std::vector<std::wstring> result;
     for (int32_t i = 0; i < count; i++)
     {
       std::string str;
       message >> str;
-      result.push_back(str);
+      result.push_back(ToUtf16String(str));
     }
     return result;
   }
 
   std::vector<SubscriptionDescription> ReadSubscriptions(Communication::InputBuffer& message)
   {
     int32_t count;
     message >> count;
 
     std::vector<SubscriptionDescription> result;
     for (int32_t i = 0; i < count; i++)
     {
       SubscriptionDescription description;
-      message >> description.url >> description.title
-              >> description.specialization >> description.listed;
+      std::string url;
+      message >> url;
+      description.url = ToUtf16String(url);
+      std::string title;
+      message >> title;
+      description.title = ToUtf16String(title);
+      std::string specialization;
+      message >> specialization;
+      description.specialization = ToUtf16String(specialization);
+      message >> description.listed;
       result.push_back(description);
     }
     return result;
   }
 
   Communication::InputBuffer CallAdblockPlusEngineProcedure(Communication::OutputBuffer& message)
   {
     std::auto_ptr<Communication::Pipe> pipe = OpenAdblockPlusEnginePipe();
     pipe->WriteMessage(message);
     return pipe->ReadMessage();
@@ skipping 89 matching lines @@
 {
   bool isHidden;
   m_criticalSectionFilter.Lock();
   {
     isHidden = filter && filter->IsElementHidden(tag, pEl, domain, indent);
   }
   m_criticalSectionFilter.Unlock();
   return isHidden;
 }
 
-bool CAdblockPlusClient::IsWhitelistedUrl(const std::string& url)
+bool CAdblockPlusClient::IsWhitelistedUrl(const std::wstring& url)
 {
   Communication::OutputBuffer request;
-  request << Communication::PROC_IS_WHITELISTED_URL << url;
+  request << Communication::PROC_IS_WHITELISTED_URL << ToUtf8String(url);
 
   try
   {
     Communication::InputBuffer response = CallAdblockPlusEngineProcedure(request);
 
     bool isWhitelisted;
     response >> isWhitelisted;
     return isWhitelisted;
   }
   catch (const std::exception& e)
@@ skipping 17 matching lines @@
   cbData = 50;
   status = RegQueryValueEx(hKey, L"Version", NULL, &type, (BYTE*)version, &cbData);
   if (status != 0)
   {
     return 0;
   }
   RegCloseKey(hKey);
   return (int)(version[0] - 48);
 }
 
-bool CAdblockPlusClient::Matches(const std::string& url, const std::string& contentType, const std::string& domain)
+bool CAdblockPlusClient::Matches(const std::wstring& url, const std::wstring& contentType, const std::wstring& domain)
 {
   Communication::OutputBuffer request;
-  request << Communication::PROC_MATCHES << url << contentType << domain;
+  request << Communication::PROC_MATCHES << ToUtf8String(url) << ToUtf8String(contentType) << ToUtf8String(domain);
 
   try
   {
     Communication::InputBuffer response = CallAdblockPlusEngineProcedure(request);
 
     bool match;
     response >> match;
     return match;
   }
   catch (const std::exception& e)
   {
     DEBUG_GENERAL(e.what());
     return false;
   }
 }
 
-std::vector<std::string> CAdblockPlusClient::GetElementHidingSelectors(const std::string& domain)
+std::vector<std::wstring> CAdblockPlusClient::GetElementHidingSelectors(const std::wstring& domain)
 {
   Communication::OutputBuffer request;
-  request << Communication::PROC_GET_ELEMHIDE_SELECTORS << domain;
+  request << Communication::PROC_GET_ELEMHIDE_SELECTORS << ToUtf8String(domain);
 
   try
   {
     Communication::InputBuffer response = CallAdblockPlusEngineProcedure(request);
     return ReadStrings(response);
   }
   catch (const std::exception& e)
   {
     DEBUG_GENERAL(e.what());
-    return std::vector<std::string>();
+    return std::vector<std::wstring>();
   }
 }
 
 std::vector<SubscriptionDescription> CAdblockPlusClient::FetchAvailableSubscriptions()
 {
   try
   {
     Communication::InputBuffer response = CallAdblockPlusEngineProcedure(Communication::PROC_AVAILABLE_SUBSCRIPTIONS);
     return ReadSubscriptions(response);
   }
@@ skipping 11 matching lines @@
     Communication::InputBuffer response = CallAdblockPlusEngineProcedure(Communication::PROC_LISTED_SUBSCRIPTIONS);
     return ReadSubscriptions(response);
   }
   catch (const std::exception& e)
   {
     DEBUG_GENERAL(e.what());
     return std::vector<SubscriptionDescription>();
   }
 }
 
-void CAdblockPlusClient::SetSubscription(std::string url)
+void CAdblockPlusClient::SetSubscription(const std::wstring& url)
 {
   Communication::OutputBuffer request;
-  request << Communication::PROC_SET_SUBSCRIPTION << url;
+  request << Communication::PROC_SET_SUBSCRIPTION << ToUtf8String(url);
 
   try
   {
     CallAdblockPlusEngineProcedure(request);
   }
   catch (const std::exception& e)
   {
     DEBUG_GENERAL(e.what());
   }
 }
 
 void CAdblockPlusClient::UpdateAllSubscriptions()
 {
   try
   {
     CallAdblockPlusEngineProcedure(Communication::PROC_UPDATE_ALL_SUBSCRIPTIONS);
   }
   catch (const std::exception& e)
   {
     DEBUG_GENERAL(e.what());
   }
 }
 
-std::vector<std::string> CAdblockPlusClient::GetExceptionDomains()
+std::vector<std::wstring> CAdblockPlusClient::GetExceptionDomains()
 {
   try
   {
     Communication::InputBuffer response = CallAdblockPlusEngineProcedure(Communication::PROC_GET_EXCEPTION_DOMAINS);
     return ReadStrings(response);
   }
   catch (const std::exception& e)
   {
     DEBUG_GENERAL(e.what());
-    return std::vector<std::string>();
+    return std::vector<std::wstring>();
   }
 }
 
-void CAdblockPlusClient::AddFilter(const std::string& text)
+void CAdblockPlusClient::AddFilter(const std::wstring& text)
 {
   Communication::OutputBuffer request;
-  request << Communication::PROC_ADD_FILTER << text;
+  request << Communication::PROC_ADD_FILTER << ToUtf8String(text);
 
   try
   {
     CallAdblockPlusEngineProcedure(request);
   }
   catch (const std::exception& e)
   {
     DEBUG_GENERAL(e.what());
   }
 }
 
-void CAdblockPlusClient::RemoveFilter(const std::string& text)
+void CAdblockPlusClient::RemoveFilter(const std::wstring& text)
 {
   Communication::OutputBuffer request;
-  request << Communication::PROC_REMOVE_FILTER << text;
+  request << Communication::PROC_REMOVE_FILTER << ToUtf8String(text);
 
   try
   {
     CallAdblockPlusEngineProcedure(request);
   }
   catch (const std::exception& e)
   {
     DEBUG_GENERAL(e.what());
   }
 }