Tooltip notification. Check for update fixes.

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;
+  HWND callbackWindow;
 
   void WriteStrings(Communication::OutputBuffer& response,
       const std::vector<std::string>& strings)
   {
     int32_t count = static_cast<int32_t>(strings.size());
     response << count;
     for (int32_t i = 0; i < count; i++)
       response << strings[i];
   }
 
   void WriteSubscriptions(Communication::OutputBuffer& response,
       const std::vector<AdblockPlus::SubscriptionPtr>& subscriptions)
   {
     int32_t count = static_cast<int32_t>(subscriptions.size());
     response << count;
     for (int32_t i = 0; i < count; i++)
     {
       AdblockPlus::SubscriptionPtr subscription = subscriptions[i];
       response << subscription->GetProperty("url")->AsString()
                << subscription->GetProperty("title")->AsString()
                << subscription->GetProperty("specialization")->AsString()
                << subscription->IsListed();
     }
   }
 
   bool updateAvailable;
+  bool checkingForUpdate = false;
   void UpdateCallback(const std::string res)
   {
+    UINT message;
     if (updateAvailable)
-      return;
-    Dictionary* dictionary = Dictionary::GetInstance();
-    if (res.length() == 0)
     {
-      std::wstring upToDateText = dictionary->Lookup("updater", "update-already-up-to-date-text");
-      std::wstring upToDateTitle = dictionary->Lookup("updater", "update-already-up-to-date-title");
-      MessageBoxW(NULL, upToDateText.c_str(), upToDateTitle.c_str(), MB_OK);
+      message = WM_DOWNLOADING_UPDATE;
     }
-    else
+    else if (res.length() == 0)
     {
-      std::wstring errorText = dictionary->Lookup("updater", "update-error-text");
-      std::wstring errorTitle = dictionary->Lookup("updater", "update-error-title");
-      ReplaceString(errorText, L"?1?", ToUtf16String(res));
-      MessageBoxW(NULL, errorText.c_str(), errorTitle.c_str(), MB_OK);
+      message = WM_ALREADY_UP_TO_DATE;
+    }
+    else 
+    {
+      message = WM_UPDATE_CHECK_ERROR;
+    }
+    if (callbackWindow)
+    {
+      SendMessage(callbackWindow, message, 0, 0);
+      checkingForUpdate = false;

[Wladimir Palant, 2013/09/19 08:59:16]

I would normally protect every access to the variable with a lock. However, I
cannot come up with a situation where not having a lock here would backfire.

+      callbackWindow = 0;
     }
     return;
   }
 
 
   CriticalSection firstRunLock;
+  CriticalSection updateCheckLock;
   bool firstRunActionExecuted = false;
   Communication::OutputBuffer HandleRequest(Communication::InputBuffer& request)
   {
     Communication::OutputBuffer response;
 
     Communication::ProcType procedure;
     request >> procedure;
     switch (procedure)
     {
       case Communication::PROC_MATCHES:
@@ skipping 156 matching lines @@
         }
         else
         {
           // Report failure
           response << false;
         }
         break;
       }
       case Communication::PROC_CHECK_FOR_UPDATES:
       {
-        updateAvailable = false;
-        filterEngine->ForceUpdateCheck(UpdateCallback);
+        request >> (int32_t&)callbackWindow;
+        CriticalSection::Lock lock(updateCheckLock);
+        if (!checkingForUpdate)
+        {
+          updateAvailable = false;
+          checkingForUpdate = true;
+          filterEngine->ForceUpdateCheck(UpdateCallback);
+        }
         break;
       }
       case Communication::PROC_IS_FIRST_RUN_ACTION_NEEDED:
       {
         CriticalSection::Lock lock(firstRunLock);
         if (!firstRunActionExecuted && filterEngine->IsFirstRun())
         {
           response << true;
           firstRunActionExecuted = true;
         }
@@ skipping 148 matching lines @@
     }
     catch (std::runtime_error e)
     {
       DebugException(e);
       return 1;
     }
   }
 
   return 0;
 }