Shut down the engine when the last tab is closed

src/engine/Main.cpp

 #include <AdblockPlus.h>
 #include <functional>
 #include <vector>
 #include <Windows.h>
 
 #include "../shared/AutoHandle.h"
 #include "../shared/Communication.h"
 #include "../shared/Dictionary.h"
 #include "../shared/Utils.h"
 #include "../shared/Version.h"
 #include "../shared/CriticalSection.h"
 #include "Debug.h"
 #include "Updater.h"
 
 namespace
 {
   std::auto_ptr<AdblockPlus::FilterEngine> filterEngine;
   std::auto_ptr<Updater> updater;
+  int activeConnections = 0;
+  CriticalSection activeConnectionsLock;
 
   void WriteStrings(Communication::OutputBuffer& response,
       const std::vector<std::string>& strings)
   {
     int32_t count = strings.size();
     response << count;
     for (int32_t i = 0; i < count; i++)
       response << strings[i];
   }
 
@@ skipping 237 matching lines @@
       }
 
     }
     return response;
   }
 
   DWORD WINAPI ClientThread(LPVOID param)
   {
     std::auto_ptr<Communication::Pipe> pipe(static_cast<Communication::Pipe*>(param));
 
-    try
+    std::stringstream stream;
+    stream << GetCurrentThreadId();
+    std::string threadId = stream.str();
+    std::string threadString = "(Thread ID: " + threadId + ")";
+    Debug("Client connected " + threadString);
+
     {
-      Communication::InputBuffer message = pipe->ReadMessage();
-      Communication::OutputBuffer response = HandleRequest(message);
-      pipe->WriteMessage(response);
-    }
-    catch (const std::exception& e)
-    {
-      DebugException(e);
+      CriticalSection::Lock lock(activeConnectionsLock);
+      activeConnections++;
     }
 
-    // TODO: Keep the pipe open until the client disconnects
+    for (;;)
+    {
+      try
+      {
+        Communication::InputBuffer message = pipe->ReadMessage();
+        Communication::OutputBuffer response = HandleRequest(message);
+        pipe->WriteMessage(response);
+      }
+      catch (const Communication::PipeDisconnectedError&)
+      {
+        break;
+      }
+      catch (const std::exception& e)
+      {
+        DebugException(e);
+        break;
+      }
+    }
+
+    Debug("Client disconnected " + threadString);
+
+    {
+      CriticalSection::Lock lock(activeConnectionsLock);
+      activeConnections--;
+      if (activeConnections < 1)
+      {
+        Debug("No connections left, shutting down the engine");
+        activeConnections = 0;
+        exit(0);
+      }
+    }
 
     return 0;
   }
 
   void OnUpdateAvailable(AdblockPlus::JsValueList& params)
   {
     updateAvailable = true;
     if (params.size() < 1)
     {
       Debug("updateAvailable event missing URL");
@@ skipping 54 matching lines @@
   filterEngine = CreateFilterEngine(locale);
   updater.reset(new Updater(filterEngine->GetJsEngine()));
 
   for (;;)
   {
     try
     {
       Communication::Pipe* pipe = new Communication::Pipe(Communication::pipeName,
             Communication::Pipe::MODE_CREATE);
 
-      // TODO: Count established connections, kill the engine when none are left
       AutoHandle thread(CreateThread(0, 0, ClientThread, static_cast<LPVOID>(pipe), 0, 0));
       if (!thread)
       {
         delete pipe;
         DebugLastError("CreateThread failed");
         return 1;
       }
     }
     catch (std::runtime_error e)
     {
       DebugException(e);
       return 1;
     }
   }
 
   return 0;
 }