Issue 1109 - Support notifications

src/engine/Main.cpp

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2015 Eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
+#pragma comment(linker,"\"/manifestdependency:type='win32' \
+  name='Microsoft.Windows.Common-Controls' version='6.0.0.0' \
+  processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")
+

[Oleksandr, 2015/06/24 01:22:34]

We have the same in PluginStdAfx.h. Maybe it makes sense to unite these and move
somewhere into common?

[sergei, 2015/06/24 17:31:35]

I don't think it's time to unite them.

Even more, I would prefer to use separate manifest files. Manifest file can
contain some properties which are applied when the application starts (like DPI
awareness), it seems useful to have all "manifest properties" in one place (in
the file) and these properties can be different between plugin and engine.

 #include <AdblockPlus.h>
 #include <functional>
 #include <vector>
 #include <thread>
 #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 "../shared/IE_version.h"
 #include "AdblockPlus.h"
 #include "Debug.h"
 #include "Updater.h"
+#include "NotificationWindow.h"
 
 namespace
 {
+  class MyModule : public ATL::CAtlExeModuleT<MyModule> {
+  public:
+  } _AtlModule;
+
   std::auto_ptr<AdblockPlus::FilterEngine> filterEngine;
   std::auto_ptr<Updater> updater;
   int activeConnections = 0;
   CriticalSection activeConnectionsLock;
   HWND callbackWindow;
 
   std::string GetWhitelistingFilter(const std::string& urlArg,
     const std::vector<std::string>& frameHierarchy, AdblockPlus::FilterEngine::ContentType type)
   {
     auto GetWhitelistingFilter = [&type](const std::string& url, const std::string& parent)->std::string
@@ skipping 402 matching lines @@
   {
     if (params.size() < 1)
     {
       Debug("updateAvailable event missing URL");
       return;
     }
     updateAvailable = true;
 
     updater->Update(params[0]->AsString());
   }
-}
 
 std::auto_ptr<AdblockPlus::FilterEngine> CreateFilterEngine(const std::wstring& locale)
 {
   AdblockPlus::AppInfo appInfo;
   appInfo.version = ToUtf8String(IEPLUGIN_VERSION);
   appInfo.name = "adblockplusie";
 #ifdef _WIN64
   appInfo.application = "msie64";
 #else
   appInfo.application = "msie32";
 #endif
   appInfo.applicationVersion = ToUtf8String(AdblockPlus::IE::InstalledVersionString());
   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", &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)
+class ScopedTimer
+{
+public:
+  explicit ScopedTimer(HWND hwnd, UINT_PTR timerId, UINT elapse, TIMERPROC timerProc)
+    : m_hwnd(hwnd), m_timerId(timerId)
+  {
+    m_timerId = SetTimer(m_hwnd, m_timerId, elapse, timerProc);
+  }
+  ~ScopedTimer()
+  {
+    Close();
+  }
+
+  UINT_PTR GetID()
+  {
+    return m_timerId;
+  }
+
+  operator bool() const
+  {
+    return m_timerId != 0;
+  }
+
+  void Close()
+  {
+    if (m_timerId)
+    {
+      KillTimer(m_hwnd, m_timerId);
+      m_timerId = 0;
+    }
+  }
+private:
+  ScopedTimer(const ScopedTimer&);
+  ScopedTimer& operator=(const ScopedTimer&);
+private:
+  HWND m_hwnd;
+  UINT_PTR m_timerId;
+};
+
+struct ScopedAtlAxInitializer
+{
+  ScopedAtlAxInitializer()
+  {
+    ATL::AtlAxWinInit();
+  }
+  ~ScopedAtlAxInitializer()
+  {
+    ATL::AtlAxWinTerm();
+  }
+};
+
+void ApplicationMessageLoop(HINSTANCE hInstance)
+{
+  const std::wstring className = L"ABPEngineMessageWindow";
+  WNDCLASS wc;
+  wc.style = 0;
+  wc.lpfnWndProc = DefWindowProcW;
+  wc.cbClsExtra = 0;
+  wc.cbWndExtra = 0;
+  wc.hInstance = hInstance;
+  wc.hIcon = nullptr;
+  wc.hCursor = nullptr;
+  wc.hbrBackground = nullptr;
+  wc.lpszMenuName = nullptr;
+  wc.lpszClassName = className.c_str();
+  ATOM atom = RegisterClass(&wc);
+  if (!atom)
+  {
+    DebugLastError("Cannot register class for message only window");
+    return;
+  }
+  HWND msgHWnd = CreateWindowW(className.c_str(),
+    nullptr,      // window name
+    0,            // style
+    0, 0, 0, 0,   // geometry (x, y, w, h)
+    HWND_MESSAGE, // parent
+    nullptr,      // menu handle
+    hInstance,
+    0);           // windows creation data.
+  if (!msgHWnd)
+  {
+    DebugLastError("Cannot create message only window");
+    return;
+  }
+  MSG msg = {};
+  ScopedTimer notificationTimer(msgHWnd, /*timer ID*/1, 3000/*msec*/, nullptr);
+  std::unique_ptr<NotificationWindow> notificationWindow;
+  while (GetMessage(&msg, /*hwnd*/nullptr, /*msgFilterMin*/0, /*msgFilterMax*/0))
+  {
+    if (msg.hwnd == msgHWnd)
+    {
+      if (msg.message == WM_TIMER)
+      {
+        if (msg.wParam == notificationTimer.GetID())
+        {
+          notificationTimer.Close();
+          auto notification = filterEngine->GetNextNotificationToShow();
+          if (notification)
+          {
+            notificationWindow.reset(new NotificationWindow(*notification, GetExeDir()));
+            notificationWindow->destroyed = [&notificationWindow]
+            {
+              notificationWindow.reset();
+            };
+            notificationWindow->linkClicked = [](const std::wstring& url)
+            {
+              ShellExecute(nullptr, L"open", url.c_str(), nullptr, nullptr, SW_SHOWNORMAL);

[Oleksandr, 2015/06/24 01:22:34]

This will open a default browser, not necessarily in IE. How about using
CoCreateInstance(CLSID_InternetExplorer ...). That way we'll be able to pass the
security info too, so there will not be the Medium Integrity requirement.

[sergei, 2015/06/24 17:31:35]

I was trying to launch internet explorer using CoCreateInstance from low IL and
to pass security info I tried CoInitializeSecurity and it does not work. Is it
what you meant? Without CoInitializeSecurity and when I pass nullptr for
security descriptor CoCreateInstance returns "Server execution failed"
(0x80080005). I'm tried to use the security descriptor which we use for pipe
(without SACL because in the documentation it's stated that SACL should be
nullptr and JIC with SACL as well as with and without DACL) and
CoInitializeSecurity returns invalid argument error. Do you know which arguments
we can use to achieve the goal and to satisfy CoInitializeSecurity ? If no, I
would propose to create an issue for it and make further investigations and fix
it in context of this issue.

+            };
+            notificationWindow->Create(/*parent window*/nullptr);
+            if (notificationWindow->operator HWND() != nullptr)
+            {
+              notificationWindow->ShowWindow(SW_SHOWNOACTIVATE);
+              notificationWindow->UpdateWindow();
+            }
+          }
+        }
+      }
+    }
+    TranslateMessage(&msg);
+    DispatchMessage(&msg);
+  }
+}
+
+} // namespace {
+
+int WINAPI WinMain(HINSTANCE 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 (;;)
+  std::thread communicationThread([]
   {
-    try
+    for (;;)
     {
-      auto pipe = std::make_shared<Communication::Pipe>(Communication::pipeName, Communication::Pipe::MODE_CREATE);
+      try
+      {
+        auto pipe = std::make_shared<Communication::Pipe>(Communication::pipeName, Communication::Pipe::MODE_CREATE);
+    
+        // TODO: we should wait for the finishing of the thread before exiting from this function.
+        // It works now in most cases because the browser waits for the response in the pipe, and the
+        // thread has time to finish while this response is being processed and the browser is
+        // disposing all its stuff.
+        std::thread([pipe]()
+        {
+          ClientThread(pipe.get());
+        }).detach();
+      }
+      catch(const std::system_error& ex)
+      {
+        DebugException(ex);
+        return 1;
+      }
+      catch (const std::runtime_error& e)
+      {
+        DebugException(e);
+        return 1;
+      }
+    }
+  });
 
-      // TODO: we should wait for the finishing of the thread before exiting from this function.
-      // It works now in most cases because the browser waits for the response in the pipe, and the
-      // thread has time to finish while this response is being processed and the browser is
-      // disposing all its stuff.
-      std::thread([pipe]()
-      {
-        ClientThread(pipe.get());
-      }).detach();
-    }
-    catch(const std::system_error& ex)
-    {
-      DebugException(ex);
-      return 1;
-    }
-    catch (const std::runtime_error& e)
-    {
-      DebugException(e);
-      return 1;
-    }
+  ScopedAtlAxInitializer atlAxInit;
+  ApplicationMessageLoop(hInstance);
+  if (communicationThread.joinable())
+  {
+    communicationThread.join();
   }
 
+
   return 0;
 }