Moved all pipe functionality into a self-containing Communication::Pipe class

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"
 #include "PluginUtil.h"
 
 #include "AdblockPlusClient.h"
 
 #include "../shared/AutoHandle.h"
 #include "../shared/Communication.h"
 
 namespace
 {
-  HANDLE OpenPipe(const std::wstring& name)
-  {
-    if (WaitNamedPipe(name.c_str(), 5000))
-      return CreateFile(name.c_str(), GENERIC_READ | GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);
-    return INVALID_HANDLE_VALUE;
-  }
-
   void SpawnAdblockPlusEngine()
   {
     std::wstring engineExecutablePath = DllDir() + L"AdblockPlusEngine.exe";
     STARTUPINFO startupInfo = {};
     PROCESS_INFORMATION processInformation = {};
 
     HANDLE token;
     OpenProcessToken(GetCurrentProcess(), TOKEN_DUPLICATE | TOKEN_ADJUST_DEFAULT | TOKEN_QUERY | TOKEN_ASSIGN_PRIMARY, &token);
     HANDLE newToken;
     DuplicateTokenEx(token, 0, 0, SecurityImpersonation, TokenPrimary, &newToken);
 
     if (!CreateProcessAsUser(newToken, 0, const_cast<wchar_t*>(engineExecutablePath.c_str()), 0, 0, 0, 0, 0, 0,
                              &startupInfo, &processInformation))
     {
       DWORD error = GetLastError();
       throw std::runtime_error("Failed to start Adblock Plus Engine");
     }
 
     CloseHandle(processInformation.hProcess);
     CloseHandle(processInformation.hThread);
   }
 
-  HANDLE OpenAdblockPlusEnginePipe()
+  std::auto_ptr<Communication::Pipe> OpenAdblockPlusEnginePipe()
   {
+    std::auto_ptr<Communication::Pipe> result;
     try
     {
-      HANDLE pipe = OpenPipe(Communication::pipeName);
-      if (pipe == INVALID_HANDLE_VALUE)
+      try
+      {
+        result.reset(new Communication::Pipe(Communication::pipeName,
+            Communication::Pipe::MODE_CONNECT));
+      }
+      catch (Communication::PipeConnectionError e)
       {
         SpawnAdblockPlusEngine();
 
         int timeout = 10000;
-        while ((pipe = OpenPipe(Communication::pipeName)) == INVALID_HANDLE_VALUE)
+        const int step = 10;
+        while (!result.get())
         {
-          const int step = 10;
-          Sleep(step);
-          timeout -= step;
-          if (timeout <= 0)
-            throw std::runtime_error("Unable to open Adblock Plus Engine pipe");
+          try
+          {
+            result.reset(new Communication::Pipe(Communication::pipeName,
+                  Communication::Pipe::MODE_CONNECT));
+          }
+          catch (Communication::PipeConnectionError e)
+          {
+            Sleep(step);
+            timeout -= step;
+            if (timeout <= 0)
+              throw std::runtime_error("Unable to open Adblock Plus Engine pipe");
+          }
         }
       }
-
-      DWORD mode = PIPE_READMODE_MESSAGE;
-      if (!SetNamedPipeHandleState(pipe, &mode, 0, 0))
-         throw std::runtime_error("SetNamedPipeHandleState failed");
-
-      return pipe;
     }
     catch(std::exception e)
     {
       DEBUG_GENERAL(e.what());
-      return INVALID_HANDLE_VALUE;
     }
+    return result;
   }
 }
 
 CAdblockPlusClient* CAdblockPlusClient::s_instance = NULL;
 
 CAdblockPlusClient::CAdblockPlusClient() : CPluginClientBase()
 {
   m_filter = std::auto_ptr<CPluginFilter>(new CPluginFilter());
 }
 
@@ skipping 115 matching lines @@
   if (status != 0)
   {
     return 0;
   }
   RegCloseKey(hKey);
   return (int)(version[0] - 48);
 }
 
 Communication::InputBuffer CallAdblockPlusEngineProcedure(Communication::OutputBuffer& message)
 {
-  AutoHandle pipe(OpenAdblockPlusEnginePipe());
-  Communication::WriteMessage(pipe.get(), message);
-  return Communication::ReadMessage(pipe.get());
+  std::auto_ptr<Communication::Pipe> pipe = OpenAdblockPlusEnginePipe();
+  pipe->WriteMessage(message);
+  return pipe->ReadMessage();
 }
 
 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;
 
   try
   {
     Communication::InputBuffer response = CallAdblockPlusEngineProcedure(request);
@@ skipping 58 matching lines @@
 {
   //TODO: implement this
   return std::vector<AdblockPlus::SubscriptionPtr>();
 }
 
 AdblockPlus::SubscriptionPtr CAdblockPlusClient::GetSubscription(std::string url)
 {
   //TODO: imlement this
   return AdblockPlus::SubscriptionPtr();
 }