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 285 matching lines @@
       {
         Debug("No connections left, shutting down the engine");
         activeConnections = 0;
         exit(0);
       }
     }
 
     return 0;
   }
 
-  void OnUpdateAvailable(AdblockPlus::JsEnginePtr jsEngine, AdblockPlus::JsValueList& params)
+  void OnUpdateAvailable(AdblockPlus::JsValueList& params)
   {
     updateAvailable = true;
     if (params.size() < 1)
     {
       Debug("updateAvailable event missing URL");
       return;
     }
 
-    Updater updater(jsEngine, params[0]->AsString());
-    updater.Update();
+    updater->SetUrl(params[0]->AsString());
+    updater->Update();
   }
 }
 
 std::auto_ptr<AdblockPlus::FilterEngine> CreateFilterEngine(const std::wstring& locale)
 {
   AdblockPlus::AppInfo appInfo;
   appInfo.version = ToUtf8String(IEPLUGIN_VERSION);
   appInfo.name = "adblockplusie";
 #ifdef _WIN64
   appInfo.platform = "msie64";
 #else
   appInfo.platform = "msie32";
 #endif
   appInfo.locale = ToUtf8String(locale);
 #ifdef ADBLOCK_PLUS_TEST_MODE
   appInfo.developmentBuild = true;
 #else
   appInfo.developmentBuild = false;
 #endif
 
   AdblockPlus::JsEnginePtr jsEngine = AdblockPlus::JsEngine::New(appInfo);
-  jsEngine->SetEventCallback("updateAvailable",
-      std::bind(&OnUpdateAvailable, jsEngine, std::placeholders::_1));
+  jsEngine->SetEventCallback("updateAvailable", &OnUpdateAvailable);
 
   std::string dataPath = ToUtf8String(GetAppDataPath());
   dynamic_cast<AdblockPlus::DefaultFileSystem*>(jsEngine->GetFileSystem().get())->SetBasePath(dataPath);
   std::auto_ptr<AdblockPlus::FilterEngine> filterEngine(new AdblockPlus::FilterEngine(jsEngine));
   return filterEngine;
 }
 
 int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
 {
   AutoHandle mutex(CreateMutexW(0, false, L"AdblockPlusEngine"));
   if (!mutex)
   {
     DebugLastError("CreateMutex failed");
     return 1;
   }
 
   if (GetLastError() == ERROR_ALREADY_EXISTS)
   {
     DebugLastError("Named pipe exists, another engine instance appears to be running");
     return 1;
   }
 
   int argc;
   LPWSTR* argv = CommandLineToArgvW(GetCommandLineW(), &argc);
   std::wstring locale(argc >= 2 ? argv[1] : L"");
   LocalFree(argv);
   Dictionary::Create(locale);
   filterEngine = CreateFilterEngine(locale);
+  updater.reset(new Updater(filterEngine->GetJsEngine()));
 
   for (;;)
   {
     try
     {
       Communication::Pipe* pipe = new Communication::Pipe(Communication::pipeName,
             Communication::Pipe::MODE_CREATE);
 
       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;
 }