Shut down the engine when the last tab is closed

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"
@@ skipping 20 matching lines @@
                               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);
   }
 
-  std::auto_ptr<Communication::Pipe> OpenAdblockPlusEnginePipe()
+  Communication::Pipe* OpenEnginePipe()
   {
     try
     {
-      return std::auto_ptr<Communication::Pipe>(new Communication::Pipe(Communication::pipeName, Communication::Pipe::MODE_CONNECT));
+      return new Communication::Pipe(Communication::pipeName, Communication::Pipe::MODE_CONNECT);
     }
     catch (Communication::PipeConnectionError e)
     {
       SpawnAdblockPlusEngine();
 
       const int step = 100;
       for (int timeout = 10000; timeout > 0; timeout -= step)
       {
         Sleep(step);
         try
         {
-          return std::auto_ptr<Communication::Pipe>(new Communication::Pipe(Communication::pipeName, Communication::Pipe::MODE_CONNECT));
+          return 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::wstring> ReadStrings(Communication::InputBuffer& message)
@@ skipping 27 matching lines @@
       message >> title;
       description.title = ToUtf16String(title);
       std::string specialization;
       message >> specialization;
       description.specialization = ToUtf16String(specialization);
       message >> description.listed;
       result.push_back(description);
     }
     return result;
   }
-
-  bool CallEngine(Communication::OutputBuffer& message, Communication::InputBuffer& inputBuffer = Communication::InputBuffer())
-  {
-    try
-    {
-      std::auto_ptr<Communication::Pipe> pipe = OpenAdblockPlusEnginePipe();
-      pipe->WriteMessage(message);
-      inputBuffer = pipe->ReadMessage();
-    }
-    catch (const std::exception& e)
-    {
-      DEBUG_GENERAL(e.what());
-      return false;
-    }
-    return true;
-  }
-
-  bool CallEngine(Communication::ProcType proc, Communication::InputBuffer& inputBuffer = Communication::InputBuffer())
-  {
-    Communication::OutputBuffer message;
-    message << proc;
-    return CallEngine(message, inputBuffer);
-  }
 }
 
 CAdblockPlusClient* CAdblockPlusClient::s_instance = NULL;
 
 CAdblockPlusClient::CAdblockPlusClient() : CPluginClientBase()
 {
   m_filter = std::auto_ptr<CPluginFilter>(new CPluginFilter());
 }
 
+bool CAdblockPlusClient::CallEngine(Communication::OutputBuffer& message, Communication::InputBuffer& inputBuffer)
+{
+  try
+  {
+    if (!enginePipe)
+      enginePipe.reset(OpenEnginePipe());

[Oleksandr, 2013/08/08 06:26:31]

Might it make sense to have some sort of a thread lock here for enginePipe?
shared_ptr is thread safe, but reassigning memory isn't.
http://stackoverflow.com/questions/14482830/stdshared-ptr-thread-safety

[Felix Dahlke, 2013/08/08 08:32:51]

Do we use a single CAdblockPlusClient instance from multiple threads? Doesn't
look like that. In that case we'd have a whole bunch of thread safety issues
here.

+    enginePipe->WriteMessage(message);
+    inputBuffer = enginePipe->ReadMessage();
+  }
+  catch (const std::exception& e)
+  {
+    DEBUG_GENERAL(e.what());
+    return false;
+  }
+  return true;
+}
+
+bool CAdblockPlusClient::CallEngine(Communication::ProcType proc, Communication::InputBuffer& inputBuffer)
+{
+  Communication::OutputBuffer message;
+  message << proc;
+  return CallEngine(message, inputBuffer);
+}
+
 CAdblockPlusClient::~CAdblockPlusClient()
 {
   s_instance = NULL;
 }
 
 
 CAdblockPlusClient* CAdblockPlusClient::GetInstance()
 {
   CAdblockPlusClient* instance = NULL;
 
@@ skipping 278 matching lines @@
 
 std::wstring CAdblockPlusClient::GetDocumentationLink()
 {
   Communication::InputBuffer response;
   if (!CallEngine(Communication::PROC_GET_DOCUMENTATION_LINK, response)) 
     return L"";
   std::wstring docLink;
   response >> docLink;
   return docLink;
 }