Issue 119 - Switch to injecting CSS for element hiding

src/plugin/PluginClass.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
@@ skipping 14 matching lines @@
 #include "AdblockPlusClient.h"
 #include "PluginClientBase.h"
 #include "PluginClientFactory.h"
 #include "PluginUtil.h"
 #include "../shared/Utils.h"
 #include "../shared/Dictionary.h"
 #include "IeVersion.h"
 #include "../shared/Version.h"
 #include <thread>
 #include <array>
+#include "WebBrowserEventsListener.h"
 
 #ifdef DEBUG_HIDE_EL
 DWORD profileTime = 0;
 #endif
 
 extern CComModule _Module;
 
 typedef HANDLE (WINAPI *OPENTHEMEDATA)(HWND, LPCWSTR);
 typedef HRESULT (WINAPI *DRAWTHEMEBACKGROUND)(HANDLE, HDC, INT, INT, LPRECT, LPRECT);
 typedef HRESULT (WINAPI *CLOSETHEMEDATA)(HANDLE);
@@ skipping 39 matching lines @@
     }
 
     int Width() const
     {
       return right - left;
     }
   };
 }
 
 CPluginClass::CPluginClass()
+  : m_data(std::make_shared<Data>())
 {
   //Use this line to debug memory leaks
   //    _CrtDumpMemoryLeaks();
 
   m_isAdvised = false;
   m_hTabWnd = NULL;
   m_hStatusBarWnd = NULL;
   m_hPaneWnd = NULL;
   m_nPaneWidth = 0;
   m_pWndProcStatus = NULL;
   m_hTheme = NULL;
   m_isInitializedOk = false;
 
 
-  m_tab = new CPluginTab(this);
-
+  m_data->tab.reset(new CPluginTab(this));
   Dictionary::Create(GetBrowserLanguage());
 }
 
 CPluginClass::~CPluginClass()
 {
-  delete m_tab;
 }
 
-
 /////////////////////////////////////////////////////////////////////////////
 // Initialization
 
 HRESULT CPluginClass::FinalConstruct()
 {
   return S_OK;
 }
 
 void CPluginClass::FinalRelease()
 {
   s_criticalSectionBrowser.Lock();
   {
-    m_webBrowser2.Release();
+    m_data.reset();
   }
   s_criticalSectionBrowser.Unlock();
 }
 
 HWND CPluginClass::GetBrowserHWND() const
 {
   SHANDLE_PTR hBrowserWndHandle = NULL;
 
   CComQIPtr<IWebBrowser2> browser = GetBrowser();
   if (browser)
   {
     HRESULT hr = browser->get_HWND(&hBrowserWndHandle);
     if (FAILED(hr))
     {
       DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_GET_BROWSER_WINDOW, "Class::GetBrowserHWND - failed")
     }
   }
 
   return (HWND)hBrowserWndHandle;
 }
 
 
 CComQIPtr<IWebBrowser2> CPluginClass::GetBrowser() const
 {
   CComQIPtr<IWebBrowser2> browser;
 
   s_criticalSectionBrowser.Lock();
   {
-    browser = m_webBrowser2;
+    browser = m_data->webBrowser2;
   }
   s_criticalSectionBrowser.Unlock();
 
   return browser;
 }
 
 
 CComQIPtr<IWebBrowser2> CPluginClass::GetAsyncBrowser()
 {
   CComQIPtr<IWebBrowser2> browser;
@@ skipping 14 matching lines @@
   if (browser)
   {
     CComBSTR bstrURL;
     if (SUCCEEDED(browser->get_LocationURL(&bstrURL)) && bstrURL)
     {
       url = std::wstring(bstrURL, SysStringLen(bstrURL));
     }
   }
   else
   {
-    url = m_tab->GetDocumentUrl();
+    url = m_data->tab->GetDocumentUrl();
   }
   return url;
 }
 
 DWORD WINAPI CPluginClass::StartInitObject(LPVOID thisPtr)
 {
   if (thisPtr == NULL)
     return 0;
   if (!((CPluginClass*)thisPtr)->InitObject())
   {
@@ skipping 23 matching lines @@
       DEBUG_GENERAL(L"================================================================================\nNEW TAB UI\n================================================================================")
 
       HRESULT hr = ::CoInitialize(NULL);
       if (FAILED(hr))
       {
         DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_SET_SITE, PLUGIN_ERROR_SET_SITE_COINIT, "Class::SetSite - CoInitialize");
       }
 
       s_criticalSectionBrowser.Lock();
       {
-        m_webBrowser2 = unknownSite;
+        m_data->webBrowser2 = ATL::CComQIPtr<IWebBrowser2>(unknownSite);
       }
       s_criticalSectionBrowser.Unlock();
 
       //register the mimefilter
       //and only mimefilter
       //on some few computers the mimefilter does not get properly registered when it is done on another thread
 
       s_criticalSectionLocal.Lock();
       {
         // Always register on startup, then check if we need to unregister in a separate thread
@@ skipping 74 matching lines @@
         {
           // TODO: Explicitly releasing a resource when a container becomes empty looks like a job better suited for shared_ptr
           CPluginClientFactory::ReleaseMimeFilterClientInstance();
         }
       }
       s_criticalSectionLocal.Unlock();
 
       // Release browser interface
       s_criticalSectionBrowser.Lock();
       {
-        m_webBrowser2.Release();
+        m_data->webBrowser2.Release();
       }
       s_criticalSectionBrowser.Unlock();
 
       DEBUG_GENERAL("================================================================================\nNEW TAB UI - END\n================================================================================")
 
       ::CoUninitialize();
     }
 
     IObjectWithSiteImpl<CPluginClass>::SetSite(unknownSite);
   }
@@ skipping 131 matching lines @@
     ATL::CComQIPtr<IWebBrowser2> webBrowser = frameBrowserDisp;
     if (!webBrowser)
     {
       return;
     }
     if (!urlVariant || urlVariant->vt != VT_BSTR)
     {
       return;
     }
     std::wstring url(urlVariant->bstrVal, SysStringLen(urlVariant->bstrVal));
+    EnsureWebBrowserConnected(webBrowser);
 
     // If webbrowser2 is equal to top level browser (as set in SetSite), we are
     // navigating new page
     CPluginClient* client = CPluginClient::GetInstance();
     if (url.find(L"javascript") == 0)
     {
     }
     else if (GetBrowser().IsEqualObject(webBrowser))
     {
-      m_tab->OnNavigate(url);
+      m_data->tab->OnNavigate(url);
       DEBUG_GENERAL(
       L"================================================================================\n"
       L"Begin main navigation url:" + url + L"\n"
       L"================================================================================")
 
 #ifdef ENABLE_DEBUG_RESULT
       CPluginDebug::DebugResultDomain(url);
 #endif
       UpdateStatusBar();
     }
     else
     {
       DEBUG_NAVI(L"Navi::Begin navigation url:" + url)
-      m_tab->CacheFrame(url);
+      m_data->tab->CacheFrame(url);
     }
   }
   catch (...)
   {
   }
 }
 
 // Entry point
 void STDMETHODCALLTYPE CPluginClass::OnDownloadComplete()
 {
   try
   {
     DEBUG_NAVI(L"Navi::Download Complete")
     ATL::CComPtr<IWebBrowser2> browser = GetBrowser();
     if (browser)
     {
-      m_tab->OnDownloadComplete(browser);
+      m_data->tab->OnDownloadComplete(browser);
     }
   }
   catch (...)
   {
   }
 }
 
 // Entry point
-void STDMETHODCALLTYPE CPluginClass::OnDocumentComplete(IDispatch* frameBrowserDisp, VARIANT* /*urlOrPidl*/)
-{
-  try
-  {
-    DEBUG_NAVI(L"Navi::Document Complete");
-    ATL::CComQIPtr<IWebBrowser2> webBrowser2 = frameBrowserDisp;
-    if (!webBrowser2)
-    {
-      return;
-    }
-    std::wstring frameSrc = GetLocationUrl(*webBrowser2);
-    bool isRootPageBrowser = GetBrowser().IsEqualObject(webBrowser2);
-    m_tab->OnDocumentComplete(webBrowser2, frameSrc, isRootPageBrowser);
-  }
-  catch (...)
-  {
-  }
-}
-
-// Entry point
 void STDMETHODCALLTYPE CPluginClass::OnWindowStateChanged(unsigned long flags, unsigned long validFlagsMask)
 {
   try
   {
     DEBUG_GENERAL(L"WindowStateChanged (check tab changed)");
     bool newtabshown = validFlagsMask == (OLECMDIDF_WINDOWSTATE_USERVISIBLE | OLECMDIDF_WINDOWSTATE_ENABLED)
       && flags == (OLECMDIDF_WINDOWSTATE_USERVISIBLE | OLECMDIDF_WINDOWSTATE_ENABLED);
     if (newtabshown)
     {
       std::map<DWORD,CPluginClass*>::const_iterator it = s_threadInstances.find(GetCurrentThreadId());
@@ skipping 412 matching lines @@
       }
     }
   }
   s_criticalSectionLocal.Unlock();
 
   return result;
 }
 
 CPluginTab* CPluginClass::GetTab()
 {
-  return m_tab;
+  return m_data->tab.get();
 }
 
 CPluginTab* CPluginClass::GetTab(DWORD dwThreadId)
 {
   CPluginTab* tab = NULL;
 
   s_criticalSectionLocal.Lock();
   {
     std::map<DWORD,CPluginClass*>::const_iterator it = s_threadInstances.find(dwThreadId);
     if (it != s_threadInstances.end())
     {
-      tab = it->second->m_tab;
+      tab = it->second->m_data->tab.get();
     }
   }
   s_criticalSectionLocal.Unlock();
 
   return tab;
 }
 
 
 STDMETHODIMP CPluginClass::QueryStatus(const GUID* pguidCmdGroup, ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT* pCmdText)
 {
@@ skipping 105 matching lines @@
           if (FAILED(hr))
           {
             DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_NAVIGATION, PLUGIN_ERROR_NAVIGATION_SETTINGS, "Navigation::Failed")
           }
         }
       }
       break;
     }
   case ID_MENU_DISABLE_ON_SITE:
     {
+      CPluginSettings* settings = CPluginSettings::GetInstance();
       std::wstring urlString = GetTab()->GetDocumentUrl();
       std::string filterText = client->GetWhitelistingFilter(urlString);
       if (!filterText.empty())
       {
         client->RemoveFilter(filterText);
       }
       else
       {
-        CPluginSettings::GetInstance()->AddWhiteListedDomain(client->GetHostFromUrl(urlString));
+        settings->AddWhiteListedDomain(client->GetHostFromUrl(urlString));
       }
     }
   default:
     break;
   }
 
   // Invalidate and redraw the control
   UpdateStatusBar();
 }
 
@@ skipping 72 matching lines @@
 
 STDMETHODIMP CPluginClass::Exec(const GUID*, DWORD nCmdID, DWORD, VARIANTARG*, VARIANTARG*)
 {
   HWND hBrowserWnd = GetBrowserHWND();
   if (!hBrowserWnd)
   {
     return E_FAIL;
   }
 
   // Create menu
-  HMENU hMenu = CreatePluginMenu(m_tab->GetDocumentUrl());
+  HMENU hMenu = CreatePluginMenu(m_data->tab->GetDocumentUrl());
   if (!hMenu)
   {
     return E_FAIL;
   }
 
   // Check if button in toolbar was pressed
   int nIDCommand = -1;
   BOOL bRightAlign = FALSE;
 
   POINT pt;
@@ skipping 377 matching lines @@
   if (m_hPaneWnd == NULL)
   {
     CreateStatusBarPane();
   }
   if ((m_hPaneWnd != NULL) && !::InvalidateRect(m_hPaneWnd, NULL, FALSE))
   {
       DEBUG_ERROR_LOG(::GetLastError(), PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_INVALIDATE_STATUSBAR, "Class::Invalidate statusbar");
   }
 }
 
-
 void CPluginClass::Unadvise()
 {
   s_criticalSectionLocal.Lock();
   {
     if (m_isAdvised)
     {
       HRESULT hr = DispEventUnadvise(GetBrowser());
       if (FAILED(hr))
       {
         DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_SET_SITE, PLUGIN_ERROR_SET_SITE_UNADVISE, "Class::Unadvise - Unadvise");
       }
       m_isAdvised = false;
     }
   }
   s_criticalSectionLocal.Unlock();
 }
 
+void CPluginClass::EnsureWebBrowserConnected(const ATL::CComPtr<IWebBrowser2>& webBrowser)
+{
+  auto it = m_data->connectedWebBrowsersCache.find(webBrowser);
+  if (it != m_data->connectedWebBrowsersCache.end())
+  {
+    return;
+  }
+  ATL::CComObject<WebBrowserEventsListener>* listenerImpl = nullptr;
+  if (FAILED(ATL::CComObject<WebBrowserEventsListener>::CreateInstance(&listenerImpl)))
+  {
+    return;
+  }
+  ATL::CComPtr<IUnknown> listenerRefCounterGuard(listenerImpl->GetUnknown());
+  std::weak_ptr<Data> dataForCapturing = m_data;
+  auto onListenerDestroy = [webBrowser, dataForCapturing]
+  {
+    if (auto data = dataForCapturing.lock())
+    {
+      data->connectedWebBrowsersCache.erase(webBrowser);
+    }
+  };
+  auto onReloaded = [webBrowser, dataForCapturing]
+  {
+    if (auto data = dataForCapturing.lock())
+    {
+      auto frameSrc = GetLocationUrl(*webBrowser);
+      data->tab->OnDocumentComplete(webBrowser, frameSrc, data->webBrowser2.IsEqualObject(webBrowser));
+    }
+  };
+  if (FAILED(listenerImpl->Init(webBrowser, onListenerDestroy, onReloaded)))
+  {
+    return;
+  }
+  m_data->connectedWebBrowsersCache.emplace(webBrowser, listenerImpl);
+}
+
 HICON CPluginClass::GetIcon(int type)
 {
   HICON icon = NULL;
 
   s_criticalSectionLocal.Lock();
   {
     if (!s_hIcons[type])
     {
       std::wstring imageToLoad = L"#";
       imageToLoad += std::to_wstring(s_hIconTypes[type]);
@@ skipping 76 matching lines @@
           s_criticalSectionLocal.Unlock();
 
         }
       }
     }
 
     hTabWnd = ::GetWindow(hTabWnd, GW_HWNDNEXT);
   }
   return hTabWnd;
 }