Issue 1173 - proposal for entry point

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
+ * 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/>.
+ */
+
 #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"
@@ skipping 57 matching lines @@
       return right - left;
     }
   };
 }
 
 CPluginClass::CPluginClass()
 {
   //Use this line to debug memory leaks
   //    _CrtDumpMemoryLeaks();
 
-  m_isAdvised = false;
+  m_isAdviced = false;
+  m_nConnectionID = 0;
   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);
@@ skipping 17 matching lines @@
 
 void CPluginClass::FinalRelease()
 {
   s_criticalSectionBrowser.Lock();
   {
     m_webBrowser2.Release();
   }
   s_criticalSectionBrowser.Unlock();
 }
 
+
+// This method tries to get a 'connection point' from the stored browser, which can be
+// used to attach or detach from the stream of browser events
+CComPtr<IConnectionPoint> CPluginClass::GetConnectionPoint()
+{
+  CComQIPtr<IConnectionPointContainer, &IID_IConnectionPointContainer> pContainer(GetBrowser());
+  if (!pContainer)
+  {
+    return NULL;
+  }
+
+  CComPtr<IConnectionPoint> pPoint;
+  HRESULT hr = pContainer->FindConnectionPoint(DIID_DWebBrowserEvents2, &pPoint);
+  if (FAILED(hr))
+  {
+    DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_SET_SITE, PLUGIN_ERROR_SET_SITE_FIND_CONNECTION_POINT, "Class::GetConnectionPoint - FindConnectionPoint")
+      return NULL;
+  }
+
+  return pPoint;
+}
+
 HWND CPluginClass::GetBrowserHWND() const
 {
   SHANDLE_PTR hBrowserWndHandle = NULL;
 
   CComQIPtr<IWebBrowser2> browser = GetBrowser();
   if (browser)
   {
     HRESULT hr = browser->get_HWND(&hBrowserWndHandle);
     if (FAILED(hr))
     {
@@ skipping 25 matching lines @@
 
   s_criticalSectionLocal.Lock();
   {
     browser = s_asyncWebBrowser2;
   }
   s_criticalSectionLocal.Unlock();
 
   return browser;
 }
 
-CString CPluginClass::GetBrowserUrl() const
-{
-  CString url;
-
+std::wstring CPluginClass::GetBrowserUrl() const
+{
+  std::wstring url;
   CComQIPtr<IWebBrowser2> browser = GetBrowser();
   if (browser)
   {
     CComBSTR bstrURL;
-
-    if (SUCCEEDED(browser->get_LocationURL(&bstrURL)))
-    {
-      url = bstrURL;
-      CPluginClient::UnescapeUrl(url);
+    if (SUCCEEDED(browser->get_LocationURL(&bstrURL)) && bstrURL)
+    {
+      url = std::wstring(bstrURL, SysStringLen(bstrURL));
+      UnescapeUrl(url);
     }
   }
   else
   {
     url = m_tab->GetDocumentUrl();
   }
-
   return url;
 }
 
 DWORD WINAPI CPluginClass::StartInitObject(LPVOID thisPtr)
 {
   if (thisPtr == NULL)
     return 0;
   if (!((CPluginClass*)thisPtr)->InitObject(true))
   {
-    ((CPluginClass*)thisPtr)->Unadvise();
+    ((CPluginClass*)thisPtr)->Unadvice();
   }
 
   return 0;
 }
 
 
 
 // This gets called when a new browser window is created (which also triggers the
 // creation of this object). The pointer passed in should be to a IWebBrowser2
 // interface that represents the browser for the window.
 // it is also called when a tab is closed, this unknownSite will be null
 // so we should handle that it is called this way several times during a session
 STDMETHODIMP CPluginClass::SetSite(IUnknown* unknownSite)
 {
   return EntryPointWithHResult([&]()->HRESULT
   {
     CPluginSettings* settings = CPluginSettings::GetInstance();
-    
+
     MULTIPLE_VERSIONS_CHECK();
-    
+
     if (unknownSite)
     {
-    
+
       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;
       }
       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
         s_mimeFilter = CPluginClientFactory::GetMimeFilterClientInstance();
         s_asyncWebBrowser2 = unknownSite;
         s_instances.insert(this);
       }
       s_criticalSectionLocal.Unlock();
-    
+
       try
       {
         // Check if loaded as BHO
-        auto webBrowser = GetBrowser();
-        if (webBrowser)
+        if (GetBrowser())
         {
           DEBUG_GENERAL("Loaded as BHO");
-          HRESULT hr = DispEventAdvise(webBrowser);
-          if (SUCCEEDED(hr))
+          CComPtr<IConnectionPoint> pPoint = GetConnectionPoint();
+          if (pPoint)
           {
-            m_isAdvised = true;
-            try
+            HRESULT hr = pPoint->Advise((IDispatch*)this, &m_nConnectionID);
+            if (SUCCEEDED(hr))
             {
-              std::thread startInitObjectThread(StartInitObject, this);
-              startInitObjectThread.detach(); // TODO: but actually we should wait for the thread in the dtr.
+              m_isAdviced = true;
+
+              try
+              {
+                std::thread startInitObjectThread(StartInitObject, this);
+                startInitObjectThread.detach(); // TODO: but actually we should wait for the thread in the dtr.
+              }
+              catch (const std::system_error& ex)
+              {
+                auto errDescription = std::string("Class::Thread - Failed to create StartInitObject thread, ") +
+                  ex.code().message() + ex.what();
+                DEBUG_ERROR_LOG(ex.code().value(), PLUGIN_ERROR_THREAD, PLUGIN_ERROR_MAIN_THREAD_CREATE_PROCESS, errDescription.c_str());
+              }
             }
-            catch (const std::system_error& ex)
+            else
             {
-              auto errDescription = std::string("Class::Thread - Failed to create StartInitObject thread, ") +
-                ex.code().message() + ex.what();
-              DEBUG_ERROR_LOG(ex.code().value(), PLUGIN_ERROR_THREAD, PLUGIN_ERROR_MAIN_THREAD_CREATE_PROCESS, errDescription.c_str());
+              DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_SET_SITE, PLUGIN_ERROR_SET_SITE_ADVICE, "Class::SetSite - Advice");
             }
           }
-          else
-          {
-            DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_SET_SITE, PLUGIN_ERROR_SET_SITE_ADVICE, "Class::SetSite - Advice");
-          }
         }
         else // Check if loaded as toolbar handler
         {
           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);
                 if (SUCCEEDED(hr))
                 {
@@ skipping 12 matching lines @@
           }
           else
           {
             DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_SET_SITE, PLUGIN_ERROR_SET_SITE_QUERY_SERVICE_PROVIDER, "Class::SetSite - QueryInterface (service provider)");
           }
         }
       }
       catch (std::runtime_error e)
       {
         DEBUG_ERROR(e.what());
-        Unadvise();
+        Unadvice();
       }
     }
     else
     {
-      Unadvise();
-    
+      // Unadvice
+      Unadvice();
+
       // Destroy window
       if (m_pWndProcStatus)
       {
         ::SetWindowLongPtr(m_hStatusBarWnd, GWLP_WNDPROC, (LPARAM)(WNDPROC)m_pWndProcStatus);
-    
+
         m_pWndProcStatus = NULL;
       }
-    
+
       if (m_hPaneWnd)
       {
         DestroyWindow(m_hPaneWnd);
         m_hPaneWnd = NULL;
       }
-    
+
       m_hTabWnd = NULL;
       m_hStatusBarWnd = NULL;
-    
+
       // Remove instance from the list, shutdown threads
       HANDLE hMainThread = NULL;
       HANDLE hTabThread = NULL;
-    
+
       s_criticalSectionLocal.Lock();
       {
         s_instances.erase(this);
-    
+
         std::map<DWORD,CPluginClass*>::iterator it = s_threadInstances.find(::GetCurrentThreadId());
         if (it != s_threadInstances.end())
         {
           s_threadInstances.erase(it);
         }
         if (s_instances.empty())
         {
           // 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();
       }
       s_criticalSectionBrowser.Unlock();
-    
+
       DEBUG_GENERAL("================================================================================\nNEW TAB UI - END\n================================================================================")
-    
+
       ::CoUninitialize();
     }
-    
+
     return IObjectWithSiteImpl<CPluginClass>::SetSite(unknownSite);
   });
 }
 
 bool CPluginClass::IsStatusBarEnabled()
 {
   DEBUG_GENERAL("IsStatusBarEnabled start");
   HKEY pHkey;
   HKEY pHkeySub;
   RegOpenCurrentUser(KEY_QUERY_VALUE, &pHkey);
@@ skipping 97 matching lines @@
       }
     }
     else
     {
       DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_GET_STATUSBAR, "Class::Get statusbar state");
     }
   }
   DEBUG_GENERAL("ShowStatusBar end");
 }
 
-void STDMETHODCALLTYPE CPluginClass::OnBeforeNavigate2(
-                        /* [in] */ IDispatch* frameBrowserDisp,
-                        /* [in] */ VARIANT* urlVariant,
-                        /* [in] */ VARIANT* /*Flags*/,
-                        /* [in] */ VARIANT* /*TargetFrameName*/,
-                        /* [in] */ VARIANT* /*PostData*/,
-                        /* [in] */ VARIANT* /*Headers*/,
-                        /* [in, out] */ VARIANT_BOOL* /*Cancel*/)
-{
-  EntryPoint([&]
-  {
-    ATL::CComQIPtr<IWebBrowser2> webBrowser = frameBrowserDisp;
-    if (!webBrowser)
-    {
-      return;
-    }
-    
-    if (!urlVariant || urlVariant->vt != VT_BSTR)
-    {
-      return;
-    }
-    std::wstring url(urlVariant->bstrVal, SysStringLen(urlVariant->bstrVal));
-    UnescapeUrl(url);
-    
-    //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);
-    
-      DEBUG_GENERAL(L"================================================================================\nBegin main navigation url:" + urlCString + "\n================================================================================")
-    
+/*
+ * #1163 This class is the implementation for method DISPID_BEFORENAVIGATE2 in CPluginClass::Invoke.
+ * - It validates and convertes its own arguments, rather than unifying them in the Invoke body.
+ * - It's declared void and not HRESULT, so DISPID_BEFORENAVIGATE2 can only return S_OK.
+ */
+void CPluginClass::BeforeNavigate2(DISPPARAMS* pDispParams)
+{
+
+  if (pDispParams->cArgs < 7)
+  {
+    return;
+  }
+  //Register a mime filter if it's not registered yet
+  if (s_mimeFilter == NULL)
+  {
+    s_mimeFilter = CPluginClientFactory::GetMimeFilterClientInstance();
+  }
+
+  // Get the IWebBrowser2 interface
+  CComQIPtr<IWebBrowser2, &IID_IWebBrowser2> WebBrowser2Ptr;
+  VARTYPE vt = pDispParams->rgvarg[6].vt;
+  if (vt == VT_DISPATCH)
+  {
+    WebBrowser2Ptr = pDispParams->rgvarg[6].pdispVal;
+  }
+  else
+  {
+    // Wrong type, return.
+    return;
+  }
+
+  // Get the URL
+  std::wstring url;
+  const auto& arg = pDispParams->rgvarg[5];
+  vt = arg.vt;
+  if (vt == (VT_BYREF | VT_VARIANT) && arg.pvarVal->vt == VT_BSTR)
+  {
+    BSTR b = arg.pvarVal->bstrVal;
+    if (b) {
+      url = std::wstring(b, SysStringLen(b));
+      UnescapeUrl(url);
+    }
+  }
+  else
+  {
+    // Wrong type, return.
+    return;
+  }
+
+  // If webbrowser2 is equal to top level browser (as set in SetSite), we are navigating new page
+  CPluginClient* client = CPluginClient::GetInstance();
+  CString urlLegacy = ToCString(url);
+  if (urlLegacy.Find(L"javascript") == 0)
+  {
+  }
+  else if (GetBrowser().IsEqualObject(WebBrowser2Ptr))
+  {
+    m_tab->OnNavigate(url);
+
+    DEBUG_GENERAL(L"================================================================================\nBegin main navigation url:" + urlLegacy + "\n================================================================================")
+
 #ifdef ENABLE_DEBUG_RESULT
-        CPluginDebug::DebugResultDomain(urlCString);
+      CPluginDebug::DebugResultDomain(urlLegacy);
 #endif
-    
-      UpdateStatusBar();
-    }
-    else
-    {
-      DEBUG_NAVI(L"Navi::Begin navigation url:" + urlCString)
-      m_tab->CacheFrame(urlCString);
-    }
-  });
-}
-
-void STDMETHODCALLTYPE CPluginClass::OnDownloadBegin()
-{
-  EntryPoint([&]
-  {
-    DEBUG_NAVI("Navi::Download Begin")
-  });
-}
-
-void STDMETHODCALLTYPE CPluginClass::OnDownloadComplete()
-{
-  EntryPoint([&]
-  {
-    DEBUG_NAVI("Navi::Download Complete")
-    ATL::CComPtr<IWebBrowser2> browser = GetBrowser();
-    if (browser)
-    {
-      m_tab->OnDownloadComplete(browser);
-    }
-  });
-}
-
-void STDMETHODCALLTYPE CPluginClass::OnDocumentComplete(IDispatch* frameBrowserDisp, VARIANT* /*urlOrPidl*/)
-{
-  EntryPoint([&]
-  {
-    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)
-{
-  EntryPoint([&]
-  {
-    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());
-      if (it == s_threadInstances.end())
-      {
-        s_threadInstances[::GetCurrentThreadId()] = this;
-        if (!m_isInitializedOk)
-        {
-          m_isInitializedOk = true;
-          InitObject(true);
-          UpdateStatusBar();
-        }
-      }
-    }
-    notificationMessage.Hide();
-    DEBUG_GENERAL("Tab change end");
-  });
-}
-
-void STDMETHODCALLTYPE CPluginClass::OnCommandStateChange(long /*command*/, VARIANT_BOOL /*enable*/)
-{
-  EntryPoint([&]
-  {
-    if (m_hPaneWnd == NULL)
-    {
-      CreateStatusBarPane();
-    }
-    else
-    {
+
+    UpdateStatusBar();
+  }
+  else
+  {
+    DEBUG_NAVI(L"Navi::Begin navigation url:" + urlLegacy)
+    m_tab->CacheFrame(url);
+  }
+}
+
+/*
+ * #1163 implements behavior for method DISPID_WINDOWSTATECHANGED in CPluginClass::Invoke
+ * - should validate and convert arguments in Invoke, not here
+ * - does not validate number of arguments before indexing into 'rgvarg'
+ * - does not validate type of argument before using its value
+ */
+STDMETHODIMP CPluginClass::OnTabChanged(DISPPARAMS* pDispParams, WORD wFlags)
+{
+  DEBUG_GENERAL("Tab changed");
+  bool newtabshown = pDispParams->rgvarg[1].intVal==3;
+  if (newtabshown)
+  {
+    std::map<DWORD,CPluginClass*>::const_iterator it = s_threadInstances.find(GetCurrentThreadId());
+    if (it == s_threadInstances.end())
+    {
+      s_threadInstances[::GetCurrentThreadId()] = this;
+      if (!m_isInitializedOk)
+      {
+        m_isInitializedOk = true;
+        InitObject(true);
+        UpdateStatusBar();
+      }
+    }
+  }
+  notificationMessage.Hide();
+  DEBUG_GENERAL("Tab change end");
+  return S_OK;
+}
+
+STDMETHODIMP CPluginClass::Invoke(DISPID dispidMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pvarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
+{
+  return EntryPointWithHResult([&]()->HRESULT
+  {
+    WCHAR tmp[256];
+    wsprintf(tmp, L"Invoke: %d\n", dispidMember);
+    DEBUG_GENERAL(tmp);
+    switch (dispidMember)
+    {
+    case DISPID_WINDOWSTATECHANGED:
+      {
+        // #1163 should validate and convert arguments here
+        return OnTabChanged(pDispParams, wFlags);
+      }
+
+    case DISPID_HTMLDOCUMENTEVENTS2_ONBEFOREUPDATE:
+      break;
+
+    case DISPID_HTMLDOCUMENTEVENTS2_ONCLICK:
+      break;
+
+    case DISPID_EVMETH_ONLOAD:
+      DEBUG_NAVI("Navi::OnLoad")
+      break;
+
+    case DISPID_EVMETH_ONCHANGE:
+      break;
+
+    case DISPID_EVMETH_ONMOUSEDOWN:
+      break;
+
+    case DISPID_EVMETH_ONMOUSEENTER:
+      break;
+
+    case DISPID_IHTMLIMGELEMENT_START:
+      break;
+
+    case STDDISPID_XOBJ_ERRORUPDATE:
+      break;
+
+    case STDDISPID_XOBJ_ONPROPERTYCHANGE:
+      break;
+
+    case DISPID_READYSTATECHANGE:
+      DEBUG_NAVI("Navi::ReadyStateChange");
+      break;
+
+    case DISPID_BEFORENAVIGATE:
+      DEBUG_NAVI("Navi::BeforeNavigate");
+      break;
+
+    case DISPID_COMMANDSTATECHANGE:
+      if (m_hPaneWnd == NULL)
+      {
+        CreateStatusBarPane();
+      }
+      else
+      {
       if (AdblockPlus::IE::InstalledMajorVersion() > 6)
-      {
-        RECT rect;
-        BOOL rectRes = GetClientRect(m_hStatusBarWnd, &rect);
-        if (rectRes == TRUE)
-        {
-          MoveWindow(m_hPaneWnd, rect.right - 200, 0, m_nPaneWidth, rect.bottom - rect.top, TRUE);
-        }
-      }
+        {
+          RECT rect;
+          BOOL rectRes = GetClientRect(m_hStatusBarWnd, &rect);
+          if (rectRes == TRUE)
+          {
+            MoveWindow(m_hPaneWnd, rect.right - 200, 0, m_nPaneWidth, rect.bottom - rect.top, TRUE);
+          }
+        }      
+      }
+      break;
+
+    case DISPID_STATUSTEXTCHANGE:
+      break;
+
+    case DISPID_BEFORENAVIGATE2:
+      {
+        // #1163 should validate and convert parameters here
+        BeforeNavigate2(pDispParams);
+      }
+      break;
+
+    case DISPID_DOWNLOADBEGIN:
+      {
+        DEBUG_NAVI("Navi::Download Begin")
+      }
+      break;
+
+    case DISPID_DOWNLOADCOMPLETE:
+      {
+        DEBUG_NAVI("Navi::Download Complete");
+        CComQIPtr<IWebBrowser2> browser = GetBrowser();
+        if (browser)
+        {
+          m_tab->OnDownloadComplete(browser);
+        }
+      }
+      break;
+
+    case DISPID_DOCUMENTCOMPLETE:
+      {
+        DEBUG_NAVI("Navi::Document Complete");
+        CComQIPtr<IWebBrowser2> browser = GetBrowser();
+        if (browser && pDispParams->cArgs >= 2 && pDispParams->rgvarg[1].vt == VT_DISPATCH)
+        {
+          CComQIPtr<IWebBrowser2> pBrowser = pDispParams->rgvarg[1].pdispVal;
+          if (pBrowser)
+          {
+            CComBSTR bstrUrl;
+            if (SUCCEEDED(pBrowser->get_LocationURL(&bstrUrl)) && bstrUrl && ::SysStringLen(bstrUrl) > 0)
+            {
+              std::wstring url = std::wstring(bstrUrl, SysStringLen(bstrUrl));
+              UnescapeUrl(url);
+              m_tab->OnDocumentComplete(browser, url, browser.IsEqualObject(pBrowser));
+            }
+          }
+        }
+      }
+      break;
+
+    case DISPID_ONQUIT:
+    case DISPID_QUIT:
+      {
+        Unadvice();
+      }
+      break;
+
+    default:
+      {
+        CString did;
+        did.Format(L"DispId:%u", dispidMember);
+
+        DEBUG_NAVI(L"Navi::Default " + did)
+      }
+      /*
+       * Ordinarily a method not dispatched should return DISP_E_MEMBERNOTFOUND.
+       * As a conservative initial change, we leave it behaving as before,
+       *   which is to do nothing and return S_OK.
+       */
+      // do nothing
+      break;
     }
   });
 }
 
 bool CPluginClass::InitObject(bool bBHO)
 {
   DEBUG_GENERAL("InitObject");
   CPluginSettings* settings = CPluginSettings::GetInstance();
 
   if (!settings->GetPluginEnabled())
@@ skipping 364 matching lines @@
   return tab;
 }
 
 
 STDMETHODIMP CPluginClass::QueryStatus(const GUID* pguidCmdGroup, ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT* pCmdText)
 {
   return EntryPointWithHResult([&]()->HRESULT
   {
     if (cCmds == 0) return E_INVALIDARG;
     if (prgCmds == 0) return E_POINTER;
-    
+
     prgCmds[0].cmdf = OLECMDF_ENABLED;
-    
+
     return S_OK;
   });
 }
 
-HMENU CPluginClass::CreatePluginMenu(const CString& url)
+HMENU CPluginClass::CreatePluginMenu(const std::wstring& url)
 {
   DEBUG_GENERAL("CreatePluginMenu");
   HINSTANCE hInstance = _AtlBaseModule.GetModuleInstance();
 
   HMENU hMenu = ::LoadMenu(hInstance, MAKEINTRESOURCE(IDR_MENU1));
 
   HMENU hMenuTrackPopup = GetSubMenu(hMenu, 0);
 
   SetMenuBar(hMenuTrackPopup, url);
 
@@ skipping 87 matching lines @@
           {
             DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_NAVIGATION, PLUGIN_ERROR_NAVIGATION_SETTINGS, "Navigation::Failed")
           }
         }
       }
       break;
     }
   case ID_MENU_DISABLE_ON_SITE:
     {
       CPluginSettings* settings = CPluginSettings::GetInstance();
-      CString urlString = GetTab()->GetDocumentUrl();
-      if (client->IsWhitelistedUrl(to_wstring(urlString)))
-      {
-        settings->RemoveWhiteListedDomain(to_CString(client->GetHostFromUrl(to_wstring(urlString))));
+      std::wstring urlString = GetTab()->GetDocumentUrl();
+      if (client->IsWhitelistedUrl(urlString))
+      {
+        settings->RemoveWhiteListedDomain(ToCString(client->GetHostFromUrl(urlString)));
       }
       else
       {
-        settings->AddWhiteListedDomain(to_CString(client->GetHostFromUrl(to_wstring(urlString))));
+        settings->AddWhiteListedDomain(ToCString(client->GetHostFromUrl(urlString)));
       }
       GetBrowser()->Refresh();
     }
   default:
     break;
   }
 
   // Invalidate and redraw the control
   UpdateStatusBar();
 }
 
 
-bool CPluginClass::SetMenuBar(HMENU hMenu, const CString& url)
+bool CPluginClass::SetMenuBar(HMENU hMenu, const std::wstring& url)
 {
   DEBUG_GENERAL("SetMenuBar");
 
   std::wstring ctext;
   Dictionary* dictionary = Dictionary::GetInstance();
 
   MENUITEMINFOW fmii = {};
   fmii.cbSize = sizeof(fmii);
 
   MENUITEMINFOW miiSep = {};
   miiSep.cbSize = sizeof(miiSep);
   miiSep.fMask = MIIM_TYPE | MIIM_FTYPE;
   miiSep.fType = MFT_SEPARATOR;
 
   CPluginClient* client = CPluginClient::GetInstance();
   CPluginSettings* settings = CPluginSettings::GetInstance();
   {
     ctext = dictionary->Lookup("menu", "menu-disable-on-site");
     // Is domain in white list?
-    ReplaceString(ctext, L"?1?", client->GetHostFromUrl(to_wstring(url)));
-    if (client->IsWhitelistedUrl(to_wstring(GetTab()->GetDocumentUrl())))
+    ReplaceString(ctext, L"?1?", client->GetHostFromUrl(url));
+    if (client->IsWhitelistedUrl(GetTab()->GetDocumentUrl()))
     {
       fmii.fState = MFS_CHECKED | MFS_ENABLED;
     }
     else
     {
       fmii.fState = MFS_UNCHECKED | MFS_ENABLED;
     }
     fmii.fMask = MIIM_STRING | MIIM_STATE;
     fmii.dwTypeData = const_cast<LPWSTR>(ctext.c_str());
     fmii.cch = static_cast<UINT>(ctext.size());
@@ skipping 39 matching lines @@
 
 STDMETHODIMP CPluginClass::Exec(const GUID*, DWORD nCmdID, DWORD, VARIANTARG*, VARIANTARG*)
 {
   return EntryPointWithHResult([&]()->HRESULT
   {
     HWND hBrowserWnd = GetBrowserHWND();
     if (!hBrowserWnd)
     {
       return E_FAIL;
     }
-    
+
     // Create menu
     HMENU hMenu = CreatePluginMenu(m_tab->GetDocumentUrl());
     if (!hMenu)
     {
       return E_FAIL;
     }
-    
+
     // Check if button in toolbar was pressed
     int nIDCommand = -1;
     BOOL bRightAlign = FALSE;
-    
+
     POINT pt;
     GetCursorPos(&pt);
-    
+
     HWND hWndToolBar = ::WindowFromPoint(pt);
-    
+
     DWORD nProcessId;
     ::GetWindowThreadProcessId(hWndToolBar, &nProcessId);
-    
+
     if (hWndToolBar && ::GetCurrentProcessId() == nProcessId)
     {
       ::ScreenToClient(hWndToolBar, &pt);
       int nButton = (int)::SendMessage(hWndToolBar, TB_HITTEST, 0, (LPARAM)&pt);
-    
+
       if (nButton > 0)
       {
         TBBUTTON pTBBtn = {};
-    
+
         if (SendMessage(hWndToolBar, TB_GETBUTTON, nButton, (LPARAM)&pTBBtn))
         {
           RECT rcButton;
           nIDCommand = pTBBtn.idCommand;
-    
+
           if (SendMessage(hWndToolBar, TB_GETRECT, nIDCommand, (LPARAM)&rcButton))
           {
             pt.x = rcButton.left;
             pt.y = rcButton.bottom;
             ClientToScreen(hWndToolBar, &pt);
-    
+
             RECT rcWorkArea;
             SystemParametersInfo(SPI_GETWORKAREA, 0, (LPVOID)&rcWorkArea, 0);
             if (rcWorkArea.right - pt.x < 150)
             {
               bRightAlign = TRUE;
               pt.x = rcButton.right;
               pt.y = rcButton.bottom;
               ClientToScreen(hWndToolBar, &pt);
             }
           }
         }
       }
       else
       {
         GetCursorPos(&pt);
       }
     }
-    
+
     // Display menu
     UINT nFlags = 0;
     if (bRightAlign)
     {
       nFlags |= TPM_RIGHTALIGN;
     }
     else
     {
       nFlags |= TPM_LEFTALIGN;
     }
-    
+
     DisplayPluginMenu(hMenu, nIDCommand, pt, nFlags);
-    
+
     return S_OK;
   });
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // Window procedures
 
 LRESULT CALLBACK CPluginClass::NewStatusProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 {
   // Find tab
@@ skipping 66 matching lines @@
   }
 
   LRESULT result = CallWindowProc(pClass->m_pWndProcStatus, hWnd, message, wParam, lParam);
 
 
   return result;
 
 }
 
 
-HICON CPluginClass::GetStatusBarIcon(const CString& url)
+HICON CPluginClass::GetStatusBarIcon(const std::wstring& url)
 {
   // use the disable icon as defualt, if the client doesn't exists
   HICON hIcon = GetIcon(ICON_PLUGIN_DEACTIVATED);
 
   CPluginTab* tab = GetTab(::GetCurrentThreadId());
   if (tab)
   {
     CPluginClient* client = CPluginClient::GetInstance();
     if (CPluginSettings::GetInstance()->IsPluginEnabled())
     {
-      if (client->IsWhitelistedUrl(ToWstring(url)))
+      if (client->IsWhitelistedUrl(url))
       {
         hIcon = GetIcon(ICON_PLUGIN_DISABLED);
       }
       else
       {
         CPluginSettings* settings = CPluginSettings::GetInstance();
         hIcon = GetIcon(ICON_PLUGIN_ENABLED);
       }
     }
   }
@@ skipping 97 matching lines @@
 
       // Done!
       EndPaint(hWnd, &ps);
 
       return 0;
     }
 
   case WM_LBUTTONUP:
   case WM_RBUTTONUP:
     {
-      CString strURL = pClass->GetBrowserUrl();
-      if (strURL != pClass->GetTab()->GetDocumentUrl())
-      {
-        pClass->GetTab()->SetDocumentUrl(strURL);
+      std::wstring url = pClass->GetBrowserUrl();
+      if (url != pClass->GetTab()->GetDocumentUrl())
+      {
+        pClass->GetTab()->SetDocumentUrl(url);
       }
 
       // Create menu
-      HMENU hMenu = pClass->CreatePluginMenu(strURL);
+      HMENU hMenu = pClass->CreatePluginMenu(url);
       if (!hMenu)
       {
         return 0;
       }
 
       // Display menu
       POINT pt;
       ::GetCursorPos(&pt);
 
       RECT rc;
@@ skipping 84 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 STDMETHODCALLTYPE CPluginClass::OnOnQuit()
-{
-  EntryPoint([&]
-  {
-    Unadvise();
-  });
-}
-
-void CPluginClass::Unadvise()
+
+void CPluginClass::Unadvice()
 {
   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;
+    if (m_isAdviced)
+    {
+      CComPtr<IConnectionPoint> pPoint = GetConnectionPoint();
+      if (pPoint)
+      {
+        HRESULT hr = pPoint->Unadvise(m_nConnectionID);
+        if (FAILED(hr))
+        {
+          DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_SET_SITE, PLUGIN_ERROR_SET_SITE_UNADVICE, "Class::Unadvice - Unadvise");
+        }
+      }
+
+      m_isAdviced = false;
     }
   }
   s_criticalSectionLocal.Unlock();
 }
 
 HICON CPluginClass::GetIcon(int type)
 {
   HICON icon = NULL;
 
   s_criticalSectionLocal.Lock();
@@ skipping 81 matching lines @@
         }
       }
     }
 
     hTabWnd = ::GetWindow(hTabWnd, GW_HWNDNEXT);
   }
 
   return hTabWnd;
 
 }