Use a proper enum type for procedures that can be called

src/plugin/AdblockPlusClient.cpp

 #include "PluginStdAfx.h"
 
 #include "PluginSettings.h"
 #include "PluginSystem.h"
 #include "PluginFilter.h"
 #include "PluginClientFactory.h"
 #include "PluginDictionary.h"
 #include "PluginHttpRequest.h"
 #include "PluginMutex.h"
 #include "PluginClass.h"
@@ skipping 223 matching lines @@
   return (int)(version[0] - 48);
 }
 
 Communication::InputBuffer CallAdblockPlusEngineProcedure(Communication::OutputBuffer& message)
 {
   std::auto_ptr<Communication::Pipe> pipe = OpenAdblockPlusEnginePipe();
   pipe->WriteMessage(message);
   return pipe->ReadMessage();
 }
 
-Communication::InputBuffer CallAdblockPlusEngineProcedure(const std::string& proc)
+Communication::InputBuffer CallAdblockPlusEngineProcedure(Communication::ProcType proc)
 {
   Communication::OutputBuffer message;
   message << proc;
   return CallAdblockPlusEngineProcedure(message);
 }
 
 bool CAdblockPlusClient::Matches(const std::string& url, const std::string& contentType, const std::string& domain)
 {
   Communication::OutputBuffer request;
-  request << std::string("Matches") << url << contentType << domain;
+  request << Communication::PROC_MATCHES << url << contentType << 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)
 {
   Communication::OutputBuffer request;
-  request << std::string("GetElementHidingSelectors") << domain;
+  request << Communication::PROC_GET_ELEMHIDE_SELECTORS << domain;
 
   try
   {
     Communication::InputBuffer response = CallAdblockPlusEngineProcedure(request);
     return ReadStrings(response);
   }
   catch (const std::exception& e)
   {
     DEBUG_GENERAL(e.what());
     return std::vector<std::string>();
   }
 }
 
 std::vector<SubscriptionDescription> CAdblockPlusClient::FetchAvailableSubscriptions()
 {
   try
   {
-    Communication::InputBuffer response = CallAdblockPlusEngineProcedure("FetchAvailableSubscriptions");
+    Communication::InputBuffer response = CallAdblockPlusEngineProcedure(Communication::PROC_AVAILABLE_SUBSCRIPTIONS);
     return ReadSubscriptions(response);
   }
   catch (const std::exception& e)
   {
     DEBUG_GENERAL(e.what());
     return std::vector<SubscriptionDescription>();
   }
 }
 
 std::vector<SubscriptionDescription> CAdblockPlusClient::GetListedSubscriptions()
 {
   try
   {
-    Communication::InputBuffer response = CallAdblockPlusEngineProcedure("GetListedSubscriptions");
+    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)
 {
   Communication::OutputBuffer request;
-  request << std::string("SetSubscription") << url;
+  request << Communication::PROC_SET_SUBSCRIPTION << url;
 
   try
   {
     CallAdblockPlusEngineProcedure(request);
   }
   catch (const std::exception& e)
   {
     DEBUG_GENERAL(e.what());
   }
 }
 
 void CAdblockPlusClient::UpdateAllSubscriptions()
 {
   try
   {
-    CallAdblockPlusEngineProcedure("UpdateAllSubscriptions");
+    CallAdblockPlusEngineProcedure(Communication::PROC_UPDATE_ALL_SUBSCRIPTIONS);
   }
   catch (const std::exception& e)
   {
     DEBUG_GENERAL(e.what());
   }
 }
 
 std::vector<std::string> CAdblockPlusClient::GetExceptionDomains()
 {
   try
   {
-    Communication::InputBuffer response = CallAdblockPlusEngineProcedure("GetExceptionDomains");
+    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>();
   }
 }
 
 void CAdblockPlusClient::AddFilter(const std::string& text)
 {
   Communication::OutputBuffer request;
-  request << std::string("AddFilter") << text;
+  request << Communication::PROC_ADD_FILTER << text;
 
   try
   {
     CallAdblockPlusEngineProcedure(request);
   }
   catch (const std::exception& e)
   {
     DEBUG_GENERAL(e.what());
   }
 }