Enhanced Protected Mode support

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;
-  volatile bool checkingForUpdate = false;
   void UpdateCallback(const std::string res)
   {
-    checkingForUpdate = false;
     if (updateAvailable)
-    {
-      if (callbackWindow != 0)
-      {
-        SendMessage(callbackWindow, WM_DOWNLOADING_UPDATE, 0, 0);
-        callbackWindow = 0;
-      }
       return;
-    }
     Dictionary* dictionary = Dictionary::GetInstance();
     if (res.length() == 0)
     {
-      if (callbackWindow != 0)
-      {
-        SendMessage(callbackWindow, WM_ALREADY_UP_TO_DATE, 0, 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);
     }
     else
     {
-      if (callbackWindow != 0)
-      {
-        SendMessage(callbackWindow, WM_UPDATE_CHECK_ERROR, 0, 0);
-      }
-    }
-    callbackWindow = 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);
+    }
     return;
   }
 
 
   CriticalSection firstRunLock;
   bool firstRunActionExecuted = false;
   Communication::OutputBuffer HandleRequest(Communication::InputBuffer& request)
   {
     Communication::OutputBuffer response;
 
@@ skipping 161 matching lines @@
         }
         else
         {
           // Report failure
           response << false;
         }
         break;
       }
       case Communication::PROC_CHECK_FOR_UPDATES:
       {
-        request >> (int32_t&)callbackWindow;
         updateAvailable = false;
-        if (!checkingForUpdate)
-        {
-          checkingForUpdate = true;
-          filterEngine->ForceUpdateCheck(UpdateCallback);
-        }
+        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 100 matching lines @@
 #endif
 
   AdblockPlus::JsEnginePtr jsEngine = AdblockPlus::JsEngine::New(appInfo);
   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;
 }
 

[Felix Dahlke, 2013/09/16 16:30:12]

Why this extra whitespace?

-
-
 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"");
-  Communication::browserSID = argv[2];

[Wladimir Palant, 2013/09/16 13:45:07]

This will cause a crash if too few parameters are passed in, please check the
number of parameters as done above.

[Felix Dahlke, 2013/09/16 16:30:12]

What if argc is <3?

[Oleksandr, 2013/09/17 03:11:37]

<3. Teehee :)

+  Communication::browserSID = argc >= 3 ? argv[2] : 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;
 }