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='*'\"")
+
 #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 "IeVersion.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;
 
   void WriteSubscriptions(Communication::OutputBuffer& response,
       const std::vector<AdblockPlus::SubscriptionPtr>& subscriptions)
   {
     int32_t count = static_cast<int32_t>(subscriptions.size());
@@ skipping 374 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() + L"html\\templates\\"));
+            notificationWindow->destroyed = [&notificationWindow]
+            {
+              notificationWindow.reset();
+            };
+            notificationWindow->linkClicked = [](const std::wstring& url)
+            {
+              ATL::CComPtr<IWebBrowser2> webBrowser;
+              if (SUCCEEDED(webBrowser.CoCreateInstance(__uuidof(InternetExplorer))) && webBrowser)
+              {
+                ATL::CComVariant emptyVariant;
+                webBrowser->Navigate(ATL::CComBSTR(url.c_str()), &emptyVariant, &emptyVariant, &emptyVariant, &emptyVariant);
+                webBrowser->put_Visible(VARIANT_TRUE);
+              }
+            };
+            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;
 }