Issue 119 - Switch to injecting CSS for element hiding

src/plugin/PluginClass.cpp

 #include "PluginStdAfx.h"
 
 #include "PluginClass.h"
 #include "PluginSettings.h"
 #include "PluginSystem.h"
 #include "PluginFilter.h"
 #include "PluginMimeFilterClient.h"
 #include "PluginClient.h"
 #include "PluginClientFactory.h"
 #include "PluginMutex.h"
 #include "sddl.h"
 #include "PluginUtil.h"
 #include "PluginUserSettings.h"
 #include "../shared/Utils.h"
 #include "../shared/Dictionary.h"
+#include "WebBrowserEventsListener.h"
 #include <thread>
 #include <array>
 
 #ifdef DEBUG_HIDE_EL
 DWORD profileTime = 0;
 #endif
 
 typedef HANDLE (WINAPI *OPENTHEMEDATA)(HWND, LPCWSTR);
 typedef HRESULT (WINAPI *DRAWTHEMEBACKGROUND)(HANDLE, HDC, INT, INT, LPRECT, LPRECT);
 typedef HRESULT (WINAPI *CLOSETHEMEDATA)(HANDLE);
@@ skipping 38 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_isAdviced = 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 17 matching lines @@
     CComBSTR bstrURL;
 
     if (SUCCEEDED(browser->get_LocationURL(&bstrURL)))
     {
       url = bstrURL;
       CPluginClient::UnescapeUrl(url);
     }
   }
   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(true))
@@ 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 36 matching lines @@
         DEBUG_GENERAL("Loaded as toolbar handler");
         CComPtr<IServiceProvider> pServiceProvider;
 
         HRESULT hr = unknownSite->QueryInterface(&pServiceProvider);
         if (SUCCEEDED(hr))
         {
           if (pServiceProvider)
           {
             s_criticalSectionBrowser.Lock();
             {
-              HRESULT hr = pServiceProvider->QueryService(IID_IWebBrowserApp, &m_webBrowser2);
+              HRESULT hr = pServiceProvider->QueryService(IID_IWebBrowserApp, &m_data->webBrowser2);
               if (SUCCEEDED(hr))
               {
-                if (m_webBrowser2)
+                if (m_data->webBrowser2)
                 {
                   InitObject(false);
                 }
               }
               else
               {
                 DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_SET_SITE, PLUGIN_ERROR_SET_SITE_QUERY_BROWSER, "Class::SetSite - QueryService (IID_IWebBrowserApp)");
               }
             }
             s_criticalSectionBrowser.Unlock();
@@ skipping 49 matching lines @@
       if (s_instances.empty())
       {
         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();
   }
 
   return IObjectWithSiteImpl<CPluginClass>::SetSite(unknownSite);
 }
@@ skipping 126 matching lines @@
     return;
   }
 
   if (!urlVariant || urlVariant->vt != VT_BSTR)
   {
     return;
   }
   std::wstring url(V_BSTR(urlVariant), SysStringLen(V_BSTR(urlVariant)));
   UnescapeUrl(url);
 
+  {

[Oleksandr, 2015/02/04 20:59:57]

I would prefer for this to be a separate function instead. Like
RegisterWebBrowserEventsListener(Data* data). In fact this could be a function
in CPluginClientFactory.

[sergei, 2015/04/13 08:06:58]

I've extracted it into CPluginClass::EnsureWebBrowserConnected

[sergei, 2015/04/13 08:06:58]

I guess here and below instead of CPluginClientFactory CPluginClass is meant.

+    auto it = m_data->connectedWebBrowsersCache.find(webBrowser);
+    if (m_data->connectedWebBrowsersCache.end() == it)

[Oleksandr, 2015/02/04 20:59:57]

This is Yoda condition, IMO

[sergei, 2015/04/13 08:06:58]

fixed

+    {
+      ATL::CComObject<WebBrowserEventsListener>* listenerImpl = nullptr;
+      if (FAILED(ATL::CComObject<WebBrowserEventsListener>::CreateInstance(&listenerImpl)))
+      {
+        return;
+      }
+      ATL::CComPtr<IUnknown> listnerRefCounterGuard(listenerImpl->GetUnknown());

[Oleksandr, 2015/02/04 20:59:57]

missing 'e'? listenerRefCounterGuard

[sergei, 2015/04/13 08:06:58]

fixed

+      std::weak_ptr<Data> dataForCapturing = m_data;
+      auto onListenerDestroy = [webBrowser, dataForCapturing]

[Oleksandr, 2015/02/04 20:59:57]

If this whole block is moved to CPluginClientFactory, I would extract
onListenerDestroy and reloaded to separate functions too

[sergei, 2015/04/13 08:06:58]

I think it will complicate the code because it is more code and anonymous
functions without any algorithmic complexity which are not relevant without the
current function only confuse. However, they could be methods of Data as well as
some other methods of CPluginClass, but let's leave it for the refactoring when
we decide that we need it.

+      {
+        if (auto data = dataForCapturing.lock())
+        {
+          data->connectedWebBrowsersCache.erase(webBrowser);
+        }
+      };
+      if (FAILED(listenerImpl->Init(webBrowser, onListenerDestroy)))
+      {
+        return;
+      }
+      listenerImpl->reloaded = [webBrowser, dataForCapturing]
+      {
+        if (auto data = dataForCapturing.lock())
+        {
+          auto frameSrc = GetLocationUrl(*webBrowser);
+          UnescapeUrl(frameSrc);
+          data->tab->OnDocumentComplete(webBrowser, ToCString(frameSrc), data->webBrowser2.IsEqualObject(webBrowser));
+        }
+      };
+      m_data->connectedWebBrowsersCache.emplace(webBrowser, listenerImpl);
+    }
+  }
+
   //Register a mime filter if it's not registered yet
   if (s_mimeFilter == NULL)
   {
     s_mimeFilter = CPluginClientFactory::GetMimeFilterClientInstance();
   }
 
   CString urlCString = ToCString(url);
 
   // If webbrowser2 is equal to top level browser (as set in SetSite), we are navigating new page
   CPluginClient* client = CPluginClient::GetInstance();
 
   if (urlCString.Find(L"javascript") == 0)
   {
   }
   else if (GetBrowser().IsEqualObject(webBrowser))
   {
-    m_tab->OnNavigate(urlCString);
+    m_data->tab->OnNavigate(urlCString);
 
     DEBUG_GENERAL(L"================================================================================\nBegin main navigation url:" + urlCString + "\n================================================================================")
 
 #ifdef ENABLE_DEBUG_RESULT
       CPluginDebug::DebugResultDomain(urlCString);
 #endif
 
     UpdateStatusBar();
   }
   else
   {
     DEBUG_NAVI(L"Navi::Begin navigation url:" + urlCString)
-    m_tab->CacheFrame(urlCString);
+    m_data->tab->CacheFrame(urlCString);
   }
 }
 
 void STDMETHODCALLTYPE CPluginClass::OnDownloadBegin()
 {
   DEBUG_NAVI("Navi::Download Begin")
 }
 
 void STDMETHODCALLTYPE CPluginClass::OnDownloadComplete()
 {
   DEBUG_NAVI("Navi::Download Complete")
   ATL::CComPtr<IWebBrowser2> browser = GetBrowser();
   if (browser)
   {
-    m_tab->OnDownloadComplete(browser);
+    m_data->tab->OnDownloadComplete(browser);
   }
 }
 
 void STDMETHODCALLTYPE CPluginClass::OnDocumentComplete(IDispatch* frameBrowserDisp, VARIANT* /*urlOrPidl*/)
 {
-  ATL::CComQIPtr<IWebBrowser2> webBrowser2 = frameBrowserDisp;
-  if (!webBrowser2)
-  {
-    return;
-  }
-  ATL::CString frameSrc;
-  ATL::CComBSTR locationUrl;
-  if (FAILED(webBrowser2->get_LocationURL(&locationUrl)) && !!locationUrl)
-  {
-    return;
-  }
-  frameSrc = locationUrl;
-  CPluginClient::UnescapeUrl(frameSrc);
-  bool isRootPageBrowser = GetBrowser().IsEqualObject(webBrowser2);
-  m_tab->OnDocumentComplete(webBrowser2, frameSrc, isRootPageBrowser);
 }
 
 void STDMETHODCALLTYPE CPluginClass::OnWindowStateChanged(unsigned long flags, unsigned long validFlagsMask)
 {
   DEBUG_GENERAL("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 382 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 214 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 488 matching lines @@
         }
       }
     }
 
     hTabWnd = ::GetWindow(hTabWnd, GW_HWNDNEXT);
   }
 
   return hTabWnd;
 
 }