Run a single FilterEngine instance in a separate process

Shared/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"
 #include "PluginUtil.h"
 
 #include "AdblockPlusClient.h"
 
 namespace
 {
-  // TODO: pipeName, bufferSize, AutoHandle, ReadMessage, WriteMessage, MarshalStrings and UnmarshalStrings are
+  // TODO: GetUserName, pipeName, bufferSize, AutoHandle, ReadMessage, WriteMessage, MarshalStrings and UnmarshalStrings are
   //       duplicated in AdblockPlusEngine. We should find a way to reuse them.
 
-  const std::wstring pipeName = L"\\\\.\\pipe\\adblockplusengine";
+  std::wstring GetUserName()
+  {
+    const DWORD maxLength = UNLEN + 1;
+    std::auto_ptr<wchar_t> buffer(new wchar_t[maxLength]);
+    DWORD length = maxLength;
+    if (!::GetUserName(buffer.get(), &length))
+    {
+      std::stringstream stream;
+      stream << "Failed to get the current user's name (Error code: " << GetLastError() << ")";
+      throw std::runtime_error("Failed to get the current user's name");
+    }
+    return std::wstring(buffer.get(), length);
+  }
+
+  const std::wstring pipeName = L"\\\\.\\pipe\\adblockplusengine_" + GetUserName();
   const int bufferSize = 1024;
 
   class AutoHandle
   {
   public:
     AutoHandle()
     {
     }
 
     AutoHandle(HANDLE handle) : handle(handle)
@@ skipping 250 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);
 }
 
-std::string CallAdblockPlusEngineProcedure(const std::string& name, const std::vector<std::string>& args)
+std::string CallAdblockPlusEngineProcedure(const std::vector<std::string>& args)
 {
   AutoHandle pipe(OpenAdblockPlusEnginePipe());
-  std::vector<std::string> strings;
-  strings.push_back(name);
-  for (std::vector<std::string>::const_iterator it = args.begin(); it != args.end(); it++)
-    strings.push_back(*it);
-  WriteMessage(pipe.get(), MarshalStrings(strings));
+  WriteMessage(pipe.get(), MarshalStrings(args));
   return ReadMessage(pipe.get());
 }
 
 bool CAdblockPlusClient::Matches(const std::string& url, const std::string& contentType, const std::string& domain)
 {
   std::vector<std::string> args;
+  args.push_back("Matches");
   args.push_back(url);
   args.push_back(contentType);
   args.push_back(domain);
 
   try
   {
-    std::string response = CallAdblockPlusEngineProcedure("Matches", args);
+    std::string response = CallAdblockPlusEngineProcedure(args);
     return response == "1";
   }
   catch (const std::exception& e)
   {
     DEBUG_GENERAL(e.what());
     return false;
   }
 }
 
 std::vector<std::string> CAdblockPlusClient::GetElementHidingSelectors(std::string domain)
 {
   std::vector<std::string> args;
+  args.push_back("GetElementHidingSelectors");
   args.push_back(domain);
 
   try
   {
-    std::string response = CallAdblockPlusEngineProcedure("GetElementHidingSelectors", args);
+    std::string response = CallAdblockPlusEngineProcedure(args);
     return UnmarshalStrings(response);
   }
   catch (const std::exception& e)
   {
     DEBUG_GENERAL(e.what());
     return std::vector<std::string>();
   }
 }
 
 std::vector<AdblockPlus::SubscriptionPtr> CAdblockPlusClient::FetchAvailableSubscriptions()
@@ skipping 18 matching lines @@
 {
   //TODO: implement this
   return std::vector<AdblockPlus::SubscriptionPtr>();
 }
 
 AdblockPlus::SubscriptionPtr CAdblockPlusClient::GetSubscription(std::string url)
 {
   //TODO: imlement this
   return AdblockPlus::SubscriptionPtr();
 }