[IE] Replace ATL::CRect

src/plugin/PluginClass.cpp

 #include "PluginStdAfx.h"
 
 #include "PluginClass.h"
 #include "PluginSettings.h"
 #include "PluginSystem.h"
 #ifdef SUPPORT_FILTER
 #include "PluginFilter.h"
 #endif
 #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 <thread>
 
-#include "COM_Client.h"
-#include "Wrapper.h"
-
 #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);
 
 HICON CPluginClass::s_hIcons[ICON_MAX] = { NULL, NULL, NULL };
 DWORD CPluginClass::s_hIconTypes[ICON_MAX] = { IDI_ICON_DISABLED, IDI_ICON_ENABLED, IDI_ICON_DEACTIVATED };
 
 CPluginMimeFilterClient* CPluginClass::s_mimeFilter = NULL;
 
 CLOSETHEMEDATA pfnClose = NULL;
 DRAWTHEMEBACKGROUND pfnDrawThemeBackground = NULL;
 OPENTHEMEDATA pfnOpenThemeData = NULL;
 
 ATOM CPluginClass::s_atomPaneClass = NULL;
 HINSTANCE CPluginClass::s_hUxtheme = NULL;
-CSimpleArray<CPluginClass*> CPluginClass::s_instances;
+std::set<CPluginClass*> CPluginClass::s_instances;
 std::map<DWORD, CPluginClass*> CPluginClass::s_threadInstances;
 
 CComAutoCriticalSection CPluginClass::s_criticalSectionLocal;
 CComAutoCriticalSection CPluginClass::s_criticalSectionBrowser;
 CComAutoCriticalSection CPluginClass::s_criticalSectionWindow;
 
 CComQIPtr<IWebBrowser2> CPluginClass::s_asyncWebBrowser2;
 
 #ifdef SUPPORT_WHITELIST
-std::map<UINT,std::wstring> CPluginClass::s_menuDomains;
+std::map<UINT,CString> CPluginClass::s_menuDomains;
 #endif
 
-//-------------------------------------------------------
-// Rectangle
-//-------------------------------------------------------
-
-namespace {

[Oleksandr, 2014/07/09 19:29:08]

Nit: New line before {

-  // Without an extra namespace within the anonymous one, the identifier "Rectangle" is ambiguous

[Felix Dahlke, 2014/07/10 04:49:03]

Hm, guess it conflicts with this one?

http://msdn.microsoft.com/en-us/library/windows/desktop/dd162898%28v=vs.85%29...

How about calling our class "Rect" or something instead?

[Eric, 2014/07/23 11:25:05]

FYI. This URL is exhibited a defect in the code review software. The left and
right parentheses are first getting quoted to "percent-28" and "percent-29",
then the percent symbols are getting quoted to "percent-25". Manually editing
the URL brings it back to working.

[Eric, 2014/07/23 12:03:18]

Well, the base class is "RECT", and it doesn't seem wise to make it differ only
in case.

Instead, I just changed the namespace to AdblockPlus. In case we ever need a
library-quality version of this class, this is likely to be its first name.

-  namespace Local {

[Oleksandr, 2014/07/09 19:29:08]

Nit: New line before {

-    /**
-     * Replacement for ATL type CRect.
-     */
-    class Rectangle
-      : public RECT
-    {
-    public:
-      // C++11 noexcept

[Felix Dahlke, 2014/07/10 04:49:03]

I guess you're marking this so we can make it noexcept later? Trouble is, it
seems like VS 2013 won't support noexcept, I don't think we should have markers
like this everywhere until we upgrade to a VS version that supports it. Let's
rather see what can be made noexcept once we can use it.

[Eric, 2014/07/23 11:25:05]

Yes.
Unfortunately, no, it doesn't. I was just reading up on this yesterday.
http://msdn.microsoft.com/en-us/library/hh567368.aspx
The trouble with that policy is that it means reanalyzing the code from scratch,
as a whole, in a year or two. If we leave comments in place, it's a simple
search-and-replace later, much faster and more effective.

In addition, the comment acts as documentation until then.

-      inline int Height() const

[Felix Dahlke, 2014/07/10 04:49:03]

inline is redundant here, since this will only be defined in one compilation
unit. And inline member functions are implicitly inline anyway.

-      {
-        return bottom - top;
-      }
-
-      // C++11 noexcept
-      inline int Width() const
-      {
-        return right - left;
-      }
-    };
-  }
-}
-
-//-------------------------------------------------------
-// CPluginClass

[Felix Dahlke, 2014/07/10 04:49:03]

We don't do class headers like this usually, I personally think it's just noise.
Oleksandr, what do you think?

[Oleksandr, 2014/07/14 07:56:21]

Visually I think it makes sense, and sometimes it's easier to get the code
structure. But let's remove these for consistency with the rest of the code.

On 2014/07/10 04:49:03, Felix H. Dahlke wrote:

-//-------------------------------------------------------
+/*
+ * Without namespace declaration, the identifier "Rectangle" is ambiguous
+ * See http://msdn.microsoft.com/en-us/library/windows/desktop/dd162898(v=vs.85).aspx
+ */
+namespace AdblockPlus

[Felix Dahlke, 2014/07/24 07:24:17]

This would normally be an anonymous namespace, so I'm not sure if we should have
it clash with the namespace used by libadblockplus. I still think the most
pragmatic way would be to just give the class a name that won't clash with
globals, i.e. "Rect".

+{
+  /**
+    * Replacement for ATL type CRect.
+    */
+  class Rectangle
+    : public RECT
+  {
+  public:
+    int Height() const
+    {
+      return bottom - top;
+    }
+
+    int Width() const
+    {
+      return right - left;
+    }
+  };
+}
+
 CPluginClass::CPluginClass()
 {
   //Use this line to debug memory leaks
   //    _CrtDumpMemoryLeaks();
 
   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);
 
   CPluginSystem* system = CPluginSystem::GetInstance();
 
-  Dictionary::Create( system->GetBrowserLanguage() );
+  std::wstring locale((LPCWSTR)system->GetBrowserLanguage());
+  Dictionary::Create(locale);
 }
 
 CPluginClass::~CPluginClass()
 {
   delete m_tab;
 }
 
 
 /////////////////////////////////////////////////////////////////////////////
 // Initialization
@@ skipping 20 matching lines @@
   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, L"Class::GetConnectionPoint - FindConnectionPoint")
+    DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_SET_SITE, PLUGIN_ERROR_SET_SITE_FIND_CONNECTION_POINT, "Class::GetConnectionPoint - FindConnectionPoint")
       return NULL;
   }
 
   return pPoint;
 }
 
 // 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::GetConnectionPointPropSink()
 {
   CComQIPtr<IConnectionPointContainer, &IID_IConnectionPointContainer> pContainer(GetBrowser());
   if (!pContainer)
   {
     return NULL;
   }
 
   CComPtr<IConnectionPoint> pPoint;
   HRESULT hr = pContainer->FindConnectionPoint(IID_IPropertyNotifySink, &pPoint);
   if (FAILED(hr))
   {
-    DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_SET_SITE, PLUGIN_ERROR_SET_SITE_FIND_CONNECTION_POINT, L"Class::GetConnectionPoint - FindConnectionPoint")
+    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))
     {
-      DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_GET_BROWSER_WINDOW, L"Class::GetBrowserHWND - failed")
+      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;
@@ skipping 14 matching lines @@
 
   s_criticalSectionLocal.Lock();
   {
     browser = s_asyncWebBrowser2;
   }
   s_criticalSectionLocal.Unlock();
 
   return browser;
 }
 
-std::wstring CPluginClass::GetBrowserUrl() const
-{
-  std::wstring url;
-
-  CComQIPtr<IWebBrowser2> ccom_browser = GetBrowser();
-  if (ccom_browser)
-  {
-    Wrapper::Browser browser( ccom_browser );
-    if ( browser.Location_URL( url ) )
-    {
-      Wrapper::Unescape_URL( url );
+CString CPluginClass::GetBrowserUrl() const
+{
+  CString url;
+
+  CComQIPtr<IWebBrowser2> browser = GetBrowser();
+  if (browser)
+  {
+    CComBSTR bstrURL;
+
+    if (SUCCEEDED(browser->get_LocationURL(&bstrURL)))
+    {
+      url = bstrURL;
+      CPluginClient::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)->Unadvice();
@@ skipping 11 matching lines @@
 // so we should handle that it is called this way several times during a session
 STDMETHODIMP CPluginClass::SetSite(IUnknown* unknownSite)
 {
   CPluginSettings* settings = CPluginSettings::GetInstance();
   CPluginSystem* system = CPluginSystem::GetInstance();
 
   MULTIPLE_VERSIONS_CHECK();
 
   if (unknownSite)
   {
-    std::wstring t[] = {
-      L"================================================================================",
-      L"NEW TAB UI",
-      L"================================================================================"
-    };
-    DEBUG_GENERAL(t);
+
+    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, L"Class::SetSite - CoInitialize");
+      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.Add(this);
+      s_instances.insert(this);
     }
     s_criticalSectionLocal.Unlock();
 
     try
     {
       // Check if loaded as BHO
       if (GetBrowser())
       {
-        DEBUG_GENERAL(L"Loaded as BHO");
+        DEBUG_GENERAL("Loaded as BHO");
         CComPtr<IConnectionPoint> pPoint = GetConnectionPoint();
         if (pPoint)
         {
           HRESULT hr = pPoint->Advise((IDispatch*)this, &m_nConnectionID);
           if (SUCCEEDED(hr))
           {
             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)
             {
-              std::wstring errDescription( L"Class::Thread - Failed to create StartInitObject thread, " );
-              errDescription += ABP::debug::widen( ex.code().message() + ex.what() );
-              DEBUG_ERROR_LOG( ex.code().value(), PLUGIN_ERROR_THREAD, PLUGIN_ERROR_MAIN_THREAD_CREATE_PROCESS, errDescription );
+              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());
             }
           }
           else
           {
-            DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_SET_SITE, PLUGIN_ERROR_SET_SITE_ADVICE, L"Class::SetSite - Advice");
+            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(L"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))
               {
                 if (m_webBrowser2)
                 {
                   InitObject(false);
                 }
               }
               else
               {
-                DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_SET_SITE, PLUGIN_ERROR_SET_SITE_QUERY_BROWSER, L"Class::SetSite - QueryService (IID_IWebBrowserApp)");
+                DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_SET_SITE, PLUGIN_ERROR_SET_SITE_QUERY_BROWSER, "Class::SetSite - QueryService (IID_IWebBrowserApp)");
               }
             }
             s_criticalSectionBrowser.Unlock();
           }
         }
         else
         {
-          DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_SET_SITE, PLUGIN_ERROR_SET_SITE_QUERY_SERVICE_PROVIDER, L"Class::SetSite - QueryInterface (service provider)");
+          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());
       Unadvice();
     }
   }
   else
@@ skipping 17 matching lines @@
 
     m_hTabWnd = NULL;
     m_hStatusBarWnd = NULL;
 
     // Remove instance from the list, shutdown threads
     HANDLE hMainThread = NULL;
     HANDLE hTabThread = NULL;
 
     s_criticalSectionLocal.Lock();
     {
-      s_instances.Remove(this);
+      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.GetSize() == 0)
+      if (s_instances.empty())
       {
         CPluginClientFactory::ReleaseMimeFilterClientInstance();
       }
     }
     s_criticalSectionLocal.Unlock();
 
     // Release browser interface
     s_criticalSectionBrowser.Lock();
     {
       m_webBrowser2.Release();
     }
     s_criticalSectionBrowser.Unlock();
 
-    std::wstring t[] = {
-      L"================================================================================",
-      L"NEW TAB UI - END",
-      L"================================================================================"
-    };
-    DEBUG_GENERAL( t );
+    DEBUG_GENERAL("================================================================================\nNEW TAB UI - END\n================================================================================")
 
     ::CoUninitialize();
   }
 
   return IObjectWithSiteImpl<CPluginClass>::SetSite(unknownSite);
 }
 
 bool CPluginClass::IsStatusBarEnabled()
 {
-  DEBUG_GENERAL(L"IsStatusBarEnabled start");
+  DEBUG_GENERAL("IsStatusBarEnabled start");
   HKEY pHkey;
   HKEY pHkeySub;
   RegOpenCurrentUser(KEY_QUERY_VALUE, &pHkey);
   DWORD trueth = 1;
   DWORD truethSize = sizeof(DWORD);
   RegOpenKey(pHkey, L"Software\\Microsoft\\Internet Explorer\\Main", &pHkeySub);
   LONG res = RegQueryValueEx(pHkeySub, L"StatusBarWeb", NULL, NULL, (BYTE*)&trueth, &truethSize);
   RegCloseKey(pHkey);
   if (res != ERROR_SUCCESS)
   {
     res = RegOpenKey(pHkey, L"Software\\Microsoft\\Internet Explorer\\MINIE", &pHkeySub);
     if (res == ERROR_SUCCESS)
     {
       LONG res = RegQueryValueEx(pHkeySub, L"ShowStatusBar", NULL, NULL, (BYTE*)&trueth, &truethSize);
       if (res == ERROR_SUCCESS)
       {
         RegCloseKey(pHkey);
       }
     }
   }
-  DEBUG_GENERAL(L"IsStatusBarEnabled end");
+  DEBUG_GENERAL("IsStatusBarEnabled end");
   return trueth == 1;
 }
 
 void CPluginClass::ShowStatusBar()
 {
-  DEBUG_GENERAL(L"ShowStatusBar start");
+  DEBUG_GENERAL("ShowStatusBar start");
 
   VARIANT_BOOL isVisible;
 
 
-  CComQIPtr<IWebBrowser2> ccom_browser = GetAsyncBrowser();
-  if (ccom_browser)
-  {
-    Wrapper::Browser browser( ccom_browser );
+  CComQIPtr<IWebBrowser2> browser = GetAsyncBrowser();
+  if (browser)
+  {
     HRESULT hr = S_OK;
-    hr = ccom_browser->get_StatusBar(&isVisible);
+    hr = browser->get_StatusBar(&isVisible);
     if (SUCCEEDED(hr))
     {
       if (!isVisible)
       {
         SHANDLE_PTR pBrowserHWnd;
-        ccom_browser->get_HWND((SHANDLE_PTR*)&pBrowserHWnd);
+        browser->get_HWND((SHANDLE_PTR*)&pBrowserHWnd);
         Dictionary* dictionary = Dictionary::GetInstance();
 
         HKEY pHkey;
         HKEY pHkeySub;
         LSTATUS regRes = 0;
         regRes = RegOpenCurrentUser(KEY_WRITE, &pHkey);
 
         // Do we have enough rights to enable a status bar?
         if (regRes != 0)
         {
@@ skipping 11 matching lines @@
             MB_YESNO);
         if (res == IDYES)
         {
           DWORD trueth = 1;
           regRes = RegOpenKey(pHkey, L"Software\\Microsoft\\Internet Explorer\\MINIE", &pHkeySub);
           regRes = RegSetValueEx(pHkeySub, L"ShowStatusBar", 0, REG_DWORD, (BYTE*)&trueth, sizeof(DWORD));
           regRes = RegCloseKey(pHkeySub);
           regRes = RegOpenKey(pHkey, L"Software\\Microsoft\\Internet Explorer\\Main", &pHkeySub);
           regRes = RegSetValueEx(pHkeySub, L"StatusBarWeb", 0, REG_DWORD, (BYTE*)&trueth, sizeof(DWORD));
           regRes = RegCloseKey(pHkeySub);
-          hr = ccom_browser->put_StatusBar(TRUE);
+          hr = browser->put_StatusBar(TRUE);
           if (FAILED(hr))
           {
-            DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_PUT_STATUSBAR, L"Class::Enable statusbar");
+            DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_PUT_STATUSBAR, "Class::Enable statusbar");
           }
           CreateStatusBarPane();
 
-          /*
-           * We need to restart the tab now, to enable the status bar properly
-           */
-          std::wstring location;
-          browser.Location_URL( location );
-          HRESULT hr = browser.navigate( location );
-          if ( FAILED(hr) )
+          // We need to restart the tab now, to enable the status bar properly
+          VARIANT vFlags;
+          vFlags.vt = VT_I4;
+          vFlags.intVal = navOpenInNewTab;
+
+          CComBSTR curLoc;
+          browser->get_LocationURL(&curLoc);
+          HRESULT hr = browser->Navigate(curLoc, &vFlags, NULL, NULL, NULL);
+          if (FAILED(hr))
           {
-            DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_NAVIGATION, PLUGIN_ERROR_NAVIGATION, L"Navigation::Failed")
+            vFlags.intVal = navOpenInNewWindow;
+
+            hr = browser->Navigate(CComBSTR(curLoc), &vFlags, NULL, NULL, NULL);
+            if (FAILED(hr))
+            {
+              DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_NAVIGATION, PLUGIN_ERROR_NAVIGATION, "Navigation::Failed")
+            }
           }
-          ccom_browser->Quit();
+          browser->Quit();
         }
       }
     }
     else
     {
-      DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_GET_STATUSBAR, L"Class::Get statusbar state");
-    }
-  }
-  DEBUG_GENERAL(L"ShowStatusBar end");
+      DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_GET_STATUSBAR, "Class::Get statusbar state");
+    }
+  }
+  DEBUG_GENERAL("ShowStatusBar end");
 }
 
 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)
   {
-    // The implementation of this assignment operator contains the QueryInterface call.
     WebBrowser2Ptr = pDispParams->rgvarg[6].pdispVal;
   }
   else
   {
     // Wrong type, return.
     return;
   }
 
   // Get the URL
-  std::wstring url;
+  CString url;
   vt = pDispParams->rgvarg[5].vt;
   if (vt == VT_BYREF + VT_VARIANT)
   {
     url = pDispParams->rgvarg[5].pvarVal->bstrVal;
-    Wrapper::Unescape_URL( url );
+
+    CPluginClient::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();
 
-  // This comparison means "begins with"
-  if ( url.compare( 0, 10, L"javascript" ) == 0 )
+  if (url.Find(L"javascript") == 0)
   {
   }
   else if (GetBrowser().IsEqualObject(WebBrowser2Ptr))
   {
-    m_tab->OnNavigate( url );
-
-    std::wstring t[] = {
-      L"================================================================================",
-      L"Begin main navigation url:" + url,
-      L"================================================================================"
-    };
-    DEBUG_GENERAL( t );
+    m_tab->OnNavigate(url);
+
+    DEBUG_GENERAL(L"================================================================================\nBegin main navigation url:" + url + "\n================================================================================")
 
 #ifdef ENABLE_DEBUG_RESULT
-      CPluginDebug::DebugResultDomain( url );
+      CPluginDebug::DebugResultDomain(url);
 #endif
 
     UpdateStatusBar();
   }
   else
   {
     DEBUG_NAVI(L"Navi::Begin navigation url:" + url)
 
 #ifdef SUPPORT_FRAME_CACHING
-      m_tab->CacheFrame( url );
+      m_tab->CacheFrame(url);
 #endif
   }
 }
 STDMETHODIMP CPluginClass::OnTabChanged(DISPPARAMS* pDispParams, WORD wFlags)
 {
-  DEBUG_GENERAL(L"Tab changed");
+  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;
         if (!InitObject(true))
         {
           //                                    Unadvice();
         }
         UpdateStatusBar();
       }
     }
   }
   notificationMessage.Hide();
-  DEBUG_GENERAL(L"Tab change end");
+  DEBUG_GENERAL("Tab change end");
   return VARIANT_TRUE;
 }
 
 // This gets called whenever there's a browser event
 STDMETHODIMP CPluginClass::Invoke(DISPID dispidMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS* pDispParams, VARIANT* pvarResult, EXCEPINFO* pExcepInfo, UINT* puArgErr)
 {
   WCHAR tmp[256];
   wsprintf(tmp, L"Invoke: %d\n", dispidMember);
   DEBUG_GENERAL(tmp);
   switch (dispidMember)
@@ skipping 40 matching lines @@
   case DISPID_BEFORENAVIGATE:
     DEBUG_NAVI("Navi::BeforeNavigate")
       return VARIANT_TRUE;
   case DISPID_COMMANDSTATECHANGE:
     if (m_hPaneWnd == NULL)
     {
       CreateStatusBarPane();
     }
     else
     {
-      if ( ABP::IE::installed_major_version() > 6 )
+      if (CPluginClient::GetInstance()->GetIEVersion() > 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);
         }
       }      
     }
     break;
@@ skipping 19 matching lines @@
       {
         m_tab->OnDownloadComplete(browser);
       }
     }
     break;
 
   case DISPID_DOCUMENTCOMPLETE:
     {
       DEBUG_NAVI("Navi::Document Complete")
 
-        CComQIPtr<IWebBrowser2> ccom_browser = GetBrowser();
-
-      if (ccom_browser && pDispParams->cArgs >= 2 && pDispParams->rgvarg[1].vt == VT_DISPATCH)
+        CComQIPtr<IWebBrowser2> browser = GetBrowser();
+
+      if (browser && pDispParams->cArgs >= 2 && pDispParams->rgvarg[1].vt == VT_DISPATCH)
       {
         CComQIPtr<IWebBrowser2> pBrowser = pDispParams->rgvarg[1].pdispVal;
         if (pBrowser)
         {
-          Wrapper::Browser browser( pBrowser );
-          std::wstring url;
-          if ( browser.Location_URL( url ) && !url.empty() )
+          CString url;
+          CComBSTR bstrUrl;
+          if (SUCCEEDED(pBrowser->get_LocationURL(&bstrUrl)) && ::SysStringLen(bstrUrl) > 0)
           {
-            Wrapper::Unescape_URL(url);
-            m_tab->OnDocumentComplete(ccom_browser, url, ccom_browser.IsEqualObject(pBrowser));
+            url = bstrUrl;
+
+            CPluginClient::UnescapeUrl(url);
+
+            m_tab->OnDocumentComplete(browser, url, browser.IsEqualObject(pBrowser));
           }
         }
       }
     }
     break;
 
   case DISPID_ONQUIT:
   case DISPID_QUIT:
     {
       Unadvice();
     }
     break;
 
   default:
     {
-      std::wostringstream msg;
-      msg << L"Navi::Default DispId:";
-      msg << static_cast< unsigned long >( dispidMember );
-      DEBUG_NAVI( msg.str() )
+      CString did;
+      did.Format(L"DispId:%u", dispidMember);
+
+      DEBUG_NAVI(L"Navi::Default " + did)
     }
 
     // do nothing
     break;
   }
 
   return VARIANT_TRUE;
 }
 
 bool CPluginClass::InitObject(bool bBHO)
 {
-  DEBUG_GENERAL(L"InitObject");
+  DEBUG_GENERAL("InitObject");
   CPluginSettings* settings = CPluginSettings::GetInstance();
 
   if (!settings->GetPluginEnabled())
   {
     s_mimeFilter->Unregister();
   }
 
   // Load theme module
   s_criticalSectionLocal.Lock();
   {
     if (!s_hUxtheme)
     {
-      s_hUxtheme = ::GetModuleHandleW(L"uxtheme.dll");
+      s_hUxtheme = ::GetModuleHandle(_T("uxtheme.dll"));
       if (s_hUxtheme)
       {
         pfnClose = (CLOSETHEMEDATA)::GetProcAddress(s_hUxtheme, "CloseThemeData");
         if (!pfnClose)
         {
-          DEBUG_ERROR_LOG(::GetLastError(), PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_GET_UXTHEME_CLOSE, L"Class::InitObject - GetProcAddress(CloseThemeData)");
+          DEBUG_ERROR_LOG(::GetLastError(), PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_GET_UXTHEME_CLOSE, "Class::InitObject - GetProcAddress(CloseThemeData)");
         }
 
         pfnDrawThemeBackground = (DRAWTHEMEBACKGROUND)::GetProcAddress(s_hUxtheme, "DrawThemeBackground");
         if (!pfnDrawThemeBackground)
         {
-          DEBUG_ERROR_LOG(::GetLastError(), PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_GET_UXTHEME_DRAW_BACKGROUND, L"Class::InitObject - GetProcAddress(DrawThemeBackground)");
+          DEBUG_ERROR_LOG(::GetLastError(), PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_GET_UXTHEME_DRAW_BACKGROUND, "Class::InitObject - GetProcAddress(DrawThemeBackground)");
         }
 
         pfnOpenThemeData = (OPENTHEMEDATA)::GetProcAddress(s_hUxtheme, "OpenThemeData");
         if (!pfnOpenThemeData)
         {
-          DEBUG_ERROR_LOG(::GetLastError(), PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_GET_UXTHEME_OPEN, L"Class::InitObject - GetProcAddress(pfnOpenThemeData)");
+          DEBUG_ERROR_LOG(::GetLastError(), PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_GET_UXTHEME_OPEN, "Class::InitObject - GetProcAddress(pfnOpenThemeData)");
         }
       }
       else
       {
-        DEBUG_ERROR_LOG(::GetLastError(), PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_GET_UXTHEME, L"Class::InitObject - GetModuleHandle(uxtheme.dll)");
+        DEBUG_ERROR_LOG(::GetLastError(), PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_GET_UXTHEME, "Class::InitObject - GetModuleHandle(uxtheme.dll)");
       }
     }
   }
   s_criticalSectionLocal.Unlock();
 
   // Register pane class
   if (!GetAtomPaneClass())
   {
     WNDCLASSEX wcex;
 
@@ skipping 11 matching lines @@
     wcex.hIconSm = NULL;
 
     s_criticalSectionLocal.Lock();
     {
       s_atomPaneClass = ::RegisterClassEx(&wcex);
     }
     s_criticalSectionLocal.Unlock();
 
     if (!GetAtomPaneClass())
     {
-      DEBUG_ERROR_LOG(::GetLastError(), PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_REGISTER_PANE_CLASS, L"Class::InitObject - RegisterClassEx");
+      DEBUG_ERROR_LOG(::GetLastError(), PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_REGISTER_PANE_CLASS, "Class::InitObject - RegisterClassEx");
       return false;
     }
   }
 
 
-  int ieVersion = ABP::IE::installed_major_version();
+  int ieVersion = CPluginClient::GetInstance()->GetIEVersion();
   // Create status pane
   if (bBHO && ieVersion > 6 && !CreateStatusBarPane())
   {
     return false;
   }
   
   if (CPluginClient::GetInstance()->IsFirstRun())
   {   
     // IE6 can't be accessed from another thread, execute in current thread
     if (ieVersion < 7)
@@ skipping 17 matching lines @@
 {
   CriticalSection::Lock lock(m_csStatusBar);
 
   CPluginClient* client = CPluginClient::GetInstance();
 
   TCHAR szClassName[MAX_PATH];
   // Get browser window and url
   HWND hBrowserWnd = GetBrowserHWND();
   if (!hBrowserWnd)
   {
-    DEBUG_ERROR_LOG(0, PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_NO_STATUSBAR_BROWSER, L"Class::CreateStatusBarPane - No status bar")
+    DEBUG_ERROR_LOG(0, PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_NO_STATUSBAR_BROWSER, "Class::CreateStatusBarPane - No status bar")
     return false;
   }
 
   // Looking for a TabWindowClass window in IE7
   // the last one should be parent for statusbar
   HWND hWndStatusBar = NULL;
 
   HWND hTabWnd = ::GetWindow(hBrowserWnd, GW_CHILD);
   UINT amoundOfNewTabs = 0;
   HWND uniqueNewTab = NULL;
@@ skipping 14 matching lines @@
       if (hTabWnd2)
       {
         DWORD nProcessId;
         ::GetWindowThreadProcessId(hTabWnd2, &nProcessId);
         if (::GetCurrentProcessId() == nProcessId)
         {
           bool bExistingTab = false;
 
           s_criticalSectionLocal.Lock();
           {
-            for (int i = 0; i < s_instances.GetSize(); i++)
+            for (auto instance : s_instances)
             {
-              if (s_instances[i]->m_hTabWnd == hTabWnd2)
+              if (instance->m_hTabWnd == hTabWnd2)
               {
-
                 bExistingTab = true;
                 break;
               }
             }
           }
           s_criticalSectionLocal.Unlock();
 
           if (!bExistingTab)
           {
             amoundOfNewTabs ++;
@@ skipping 22 matching lines @@
     {
       hWndStatusBar = hWnd;
       break;
     }
 
     hWnd = ::GetWindow(hWnd, GW_HWNDNEXT);
   }
 
   if (!hWndStatusBar)
   {
-    DEBUG_ERROR_LOG(0, PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_NO_STATUSBAR_WIN, L"Class::CreateStatusBarPane - No status bar")
+    DEBUG_ERROR_LOG(0, PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_NO_STATUSBAR_WIN, "Class::CreateStatusBarPane - No status bar")
     return true;
   }
 
   // Calculate pane height
-  Local::Rectangle rcStatusBar;
+  AdblockPlus::Rectangle rcStatusBar;
   ::GetClientRect(hWndStatusBar, &rcStatusBar);
 
   if (rcStatusBar.Height() > 0)
   {
 #ifdef _DEBUG
     m_nPaneWidth = 70;
 #else
     m_nPaneWidth = min(rcStatusBar.Height(), 22);
 #endif
   }
@@ skipping 12 matching lines @@
     _T(""),
     WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
     rcStatusBar.Width() - 500,0,m_nPaneWidth,rcStatusBar.Height(),
     hWndStatusBar,
     (HMENU)3671,
     _Module.m_hInst,
     NULL);
 
   if (!hWndNewPane)
   {
-    DEBUG_ERROR_LOG(::GetLastError(), PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_CREATE_STATUSBAR_PANE, L"Class::CreateStatusBarPane - CreateWindowEx")
+    DEBUG_ERROR_LOG(::GetLastError(), PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_CREATE_STATUSBAR_PANE, "Class::CreateStatusBarPane - CreateWindowEx")
     return false;
   }
 
-  DEBUG_GENERAL(L"ABP window created");
+  DEBUG_GENERAL("ABP window created");
   m_hTabWnd = hTabWnd;
   m_hStatusBarWnd = hWndStatusBar;
   m_hPaneWnd = hWndNewPane;
 
   UpdateTheme();
 
   // Subclass status bar
   m_pWndProcStatus = (WNDPROC)SetWindowLongPtr(hWndStatusBar, GWLP_WNDPROC, (LPARAM)(WNDPROC)NewStatusProc);
 
   // Adjust pane
@@ skipping 12 matching lines @@
   HDC hdc = GetWindowDC(m_hStatusBarWnd);
   SendMessage(m_hStatusBarWnd, WM_PAINT, (WPARAM)hdc, 0);
   ReleaseDC(m_hStatusBarWnd, hdc);
   
   return true;
 }
 
 void CPluginClass::FirstRunThread()
 {
   CoInitialize(NULL);
-
-  Wrapper::Browser browser( GetAsyncBrowser() );
-  HRESULT hr = browser.navigate( FirstRunPageFileUrl() );
-  if ( FAILED( hr ) )
-  {
-    DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_NAVIGATION, PLUGIN_ERROR_NAVIGATION_WELCOME, L"Navigation::Welcome page failed")
-  }
-}
-
+  VARIANT vFlags;
+  vFlags.vt = VT_I4;
+  vFlags.intVal = navOpenInNewTab;
+
+  CComBSTR navigatePath = CComBSTR(FirstRunPageFileUrl().c_str());
+  
+  HRESULT hr = GetAsyncBrowser()->Navigate(navigatePath, &vFlags, NULL, NULL, NULL);
+  if (FAILED(hr))
+  {
+    vFlags.intVal = navOpenInNewWindow;
+    hr = GetAsyncBrowser()->Navigate(navigatePath, &vFlags, NULL, NULL, NULL);
+  }
+
+  if (FAILED(hr))
+  {
+    DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_NAVIGATION, PLUGIN_ERROR_NAVIGATION_WELCOME, "Navigation::Welcome page failed")
+  }
+}
 void CPluginClass::CloseTheme()
 {
   if (m_hTheme)
   {
     if (pfnClose)
     {
       pfnClose(m_hTheme);
     }
 
     m_hTheme = NULL;
   }
 }
 
 void CPluginClass::UpdateTheme()
 {
   CloseTheme();
 
   if (pfnOpenThemeData)
   {
     m_hTheme = pfnOpenThemeData(m_hPaneWnd, L"STATUS");
     if (!m_hTheme)
     {
     }
   }
 }
 
 
 CPluginClass* CPluginClass::FindInstance(HWND hStatusBarWnd)
 {
-  CPluginClass* instance = NULL;
+  CPluginClass* return_instance = nullptr;
 
   s_criticalSectionLocal.Lock();
   {
-    for (int i = 0; i < s_instances.GetSize(); i++)
-    {
-      if (s_instances[i]->m_hStatusBarWnd == hStatusBarWnd)
-      {
-        instance = s_instances[i];
+    for (auto instance : s_instances)
+    {
+      if (instance->m_hStatusBarWnd == hStatusBarWnd)
+      {
+        return_instance = instance;
         break;
       }
     }
   }
   s_criticalSectionLocal.Unlock();
 
-  return instance;
+  return return_instance;
 }
 
 CPluginTab* CPluginClass::GetTab()
 {
   return m_tab;
 }
 
 CPluginTab* CPluginClass::GetTab(DWORD dwThreadId)
 {
   CPluginTab* tab = NULL;
@@ skipping 15 matching lines @@
 STDMETHODIMP CPluginClass::QueryStatus(const GUID* pguidCmdGroup, ULONG cCmds, OLECMD prgCmds[], OLECMDTEXT* pCmdText)
 {
   if (cCmds == 0) return E_INVALIDARG;
   if (prgCmds == 0) return E_POINTER;
 
   prgCmds[0].cmdf = OLECMDF_ENABLED;
 
   return S_OK;
 }
 
-HMENU CPluginClass::CreatePluginMenu(const std::wstring & url)
-{
-  DEBUG_GENERAL(L"CreatePluginMenu");
+HMENU CPluginClass::CreatePluginMenu(const CString& url)
+{
+  DEBUG_GENERAL("CreatePluginMenu");
   HINSTANCE hInstance = _AtlBaseModule.GetModuleInstance();
 
   HMENU hMenu = ::LoadMenu(hInstance, MAKEINTRESOURCE(IDR_MENU1));
 
   HMENU hMenuTrackPopup = GetSubMenu(hMenu, 0);
 
   SetMenuBar(hMenuTrackPopup, url);
 
   return hMenuTrackPopup;
 }
@@ skipping 174 matching lines @@
         }
       }
       s_criticalSectionLocal.Unlock();
     }
     break;
   case ID_MENU_SETTINGS:
     {
       CComQIPtr<IWebBrowser2> browser = GetAsyncBrowser();
       if (browser)
       {
-        Wrapper::Browser b( browser );
-        HRESULT hr = b.navigate( UserSettingsFileUrl() );
-        if ( FAILED(hr) )
+        VARIANT vFlags;
+        vFlags.vt = VT_I4;
+        vFlags.intVal = navOpenInNewTab;
+
+        BSTR urlToNavigate = BString(UserSettingsFileUrl());
+        HRESULT hr = browser->Navigate(urlToNavigate, &vFlags, NULL, NULL, NULL);
+        if (FAILED(hr))
         {
-          DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_NAVIGATION, PLUGIN_ERROR_NAVIGATION_SETTINGS, L"Navigation::Failed")
+          vFlags.intVal = navOpenInNewWindow;
+
+          hr = browser->Navigate(urlToNavigate, &vFlags, NULL, NULL, NULL);
+          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();
-      if (client->IsWhitelistedUrl(urlString))
-      {
-        settings->RemoveWhiteListedDomain( client->GetHostFromUrl( urlString ).c_str() );
+      CString urlString = GetTab()->GetDocumentUrl();
+      if (client->IsWhitelistedUrl(std::wstring(urlString)))
+      {
+        settings->RemoveWhiteListedDomain(client->GetHostFromUrl(urlString.GetString()).c_str());
       }
       else
       {
-        settings->AddWhiteListedDomain( client->GetHostFromUrl( urlString).c_str());
+        settings->AddWhiteListedDomain(client->GetHostFromUrl(urlString.GetString()).c_str());
       }
       GetBrowser()->Refresh();
     }
   default:
     break;
   }
 
   // Invalidate and redraw the control
   UpdateStatusBar();
 }
 
 
-bool CPluginClass::SetMenuBar(HMENU hMenu, const std::wstring & url)
-{
-  DEBUG_GENERAL(L"SetMenuBar");
+bool CPluginClass::SetMenuBar(HMENU hMenu, const CString& url)
+{
+  DEBUG_GENERAL("SetMenuBar");
 
   std::wstring ctext;
 
   s_criticalSectionLocal.Lock();
   {
 #ifdef SUPPORT_WHITELIST
     s_menuDomains.clear();
 #endif
   }
   s_criticalSectionLocal.Unlock();
@@ skipping 12 matching lines @@
   miiSep.fType = MFT_SEPARATOR;
 
   CPluginClient* client = CPluginClient::GetInstance();
 
   CPluginSettings* settings = CPluginSettings::GetInstance();
 
 #ifdef SUPPORT_WHITELIST
   {
     ctext = dictionary->Lookup("menu", "menu-disable-on-site");
     // Is domain in white list?
-    ReplaceString(ctext, L"?1?", client->GetHostFromUrl(url));
+    ReplaceString(ctext, L"?1?", client->GetHostFromUrl(url.GetString()));
     if (client->IsWhitelistedUrl(std::wstring(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());
@@ skipping 168 matching lines @@
       HLOCAL hLocal = LocalAlloc(LHND, sizeof(int) * (nParts+1));
       LPINT lpParts = (LPINT)LocalLock(hLocal);
       memcpy(lpParts, (void*)lParam, wParam*sizeof(int));
 
       for (unsigned i = 0; i < STATUSBAR_PANE_NUMBER; i++)
       {
         lpParts[i] -= pClass->m_nPaneWidth;
       }
       LRESULT hRet = CallWindowProc(pClass->m_pWndProcStatus, hWnd, message, wParam, (LPARAM)lpParts);
 
-      Local::Rectangle rcPane;
+      AdblockPlus::Rectangle rcPane;
       ::SendMessage(hWnd, SB_GETRECT, STATUSBAR_PANE_NUMBER, (LPARAM)&rcPane);
 
-      Local::Rectangle rcClient;
+      AdblockPlus::Rectangle rcClient;
       ::GetClientRect(hWnd, &rcClient);
 
       ::MoveWindow(
         pClass->m_hPaneWnd,
         lpParts[STATUSBAR_PANE_NUMBER] - pClass->m_nPaneWidth,
         0,
         pClass->m_nPaneWidth,
         rcClient.Height(),
         TRUE);
 
       ::LocalFree(hLocal);
 
 
       return hRet;
     }
 
   default:
     break;
   }
 
   LRESULT result = CallWindowProc(pClass->m_pWndProcStatus, hWnd, message, wParam, lParam);
 
 
   return result;
 
 }
 
 
-HICON CPluginClass::GetStatusBarIcon(const std::wstring & url)
+HICON CPluginClass::GetStatusBarIcon(const CString& 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();
 
 #ifdef PRODUCT_ADBLOCKPLUS
     if (!CPluginSettings::GetInstance()->IsPluginEnabled())
     {
     }
 #ifdef SUPPORT_WHITELIST
-    else if (client->IsWhitelistedUrl( url ))
+    else if (client->IsWhitelistedUrl(std::wstring(url)))
     {
       hIcon = GetIcon(ICON_PLUGIN_DISABLED);
     }
 #endif // SUPPORT_WHITELIST
     else
     {
       CPluginSettings* settings = CPluginSettings::GetInstance();
       hIcon = GetIcon(ICON_PLUGIN_ENABLED);
     }
 
@@ skipping 22 matching lines @@
   case WM_SETCURSOR:
     {
       ::SetCursor(::LoadCursor(NULL, IDC_ARROW));
       return TRUE;
     }
   case WM_PAINT:
     {
       PAINTSTRUCT ps;
       HDC hDC = ::BeginPaint(hWnd, &ps);
 
-      Local::Rectangle rcClient;
+      AdblockPlus::Rectangle rcClient;
       ::GetClientRect(hWnd, &rcClient);
 
       int nDrawEdge = 0;
 
       // Old Windows background drawing
       if (pClass->m_hTheme == NULL)
       {
         ::FillRect(hDC, &rcClient, (HBRUSH)(COLOR_BTNFACE + 1));
         ::DrawEdge(hDC, &rcClient, BDR_RAISEDINNER, BF_LEFT);
 
         nDrawEdge = 3;
         rcClient.left += 3;
 
         ::DrawEdge(hDC, &rcClient, BDR_SUNKENOUTER, BF_RECT);
       }
       // Themed background drawing
       else
       {
         // Draw background
         if (pfnDrawThemeBackground)
         {
-          Local::Rectangle rc = rcClient;
+          AdblockPlus::Rectangle rc = rcClient;
           rc.right -= 2;
           pfnDrawThemeBackground(pClass->m_hTheme, hDC, 0, 0, &rc, NULL);
         }
 
         // Copy separator picture to left side
         int nHeight = rcClient.Height();
         int nWidth = rcClient.Width() - 2;
 
         for (int i = 0; i < 2; i++)
         {
           for (int j = 0; j < nHeight; j++)
           {
             COLORREF clr = ::GetPixel(hDC, i + nWidth, j);
 
             // Ignore black boxes (if source is obscured by other windows)
             if (clr != -1 && (GetRValue(clr) > 8 || GetGValue(clr) > 8 || GetBValue(clr) > 8))
             {
               ::SetPixel(hDC, i, j, clr);
             }
           }
         }
       }
 
       // Draw icon
       if (CPluginClient::GetInstance())
       {
-        HICON hIcon = GetStatusBarIcon(pClass->GetTab()->GetDocumentUrl().c_str());
+        HICON hIcon = GetStatusBarIcon(pClass->GetTab()->GetDocumentUrl());
 
         int offx = (rcClient.Height() - 16)/2 + nDrawEdge;
         if (hIcon)
         {
           ::DrawIconEx(hDC, offx, (rcClient.Height() - 16)/2 + 2, hIcon, 16, 16, NULL, NULL, DI_NORMAL);
           offx += 22;
         }
 #ifdef _DEBUG
         // Display version
         HFONT hFont = (HFONT)::SendMessage(pClass->m_hStatusBarWnd, WM_GETFONT, 0, 0);
         HGDIOBJ hOldFont = ::SelectObject(hDC,hFont);
 
-        Local::Rectangle rcText = rcClient;
+        AdblockPlus::Rectangle rcText = rcClient;
         rcText.left += offx;
         ::SetBkMode(hDC, TRANSPARENT);
         ::DrawTextW(hDC, IEPLUGIN_VERSION, -1, &rcText, DT_WORD_ELLIPSIS|DT_LEFT|DT_SINGLELINE|DT_VCENTER);
 
         ::SelectObject(hDC, hOldFont);
 #endif // _DEBUG
       }
 
       // Done!
       EndPaint(hWnd, &ps);
 
       return 0;
     }
 
   case WM_LBUTTONUP:
   case WM_RBUTTONUP:
     {
-      std::wstring url = pClass->GetBrowserUrl();
-      if (url != pClass->GetTab()->GetDocumentUrl())
-      {
-        pClass->GetTab()->SetDocumentUrl( url );
+      CString strURL = pClass->GetBrowserUrl();
+      if (strURL != pClass->GetTab()->GetDocumentUrl())
+      {
+        pClass->GetTab()->SetDocumentUrl(strURL);
       }
 
       // Create menu
-      HMENU hMenu = pClass->CreatePluginMenu( url );
+      HMENU hMenu = pClass->CreatePluginMenu(strURL);
       if (!hMenu)
       {
         return 0;
       }
 
       // Display menu
       POINT pt;
       ::GetCursorPos(&pt);
 
       RECT rc;
@@ skipping 73 matching lines @@
     }
     break;
   }
 
   return DefWindowProc(hWnd, message, wParam, lParam);
 }
 
 
 void CPluginClass::UpdateStatusBar()
 {
-  DEBUG_GENERAL(L"*** Updating statusbar")
+  DEBUG_GENERAL("*** Updating statusbar")
   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, L"Class::Invalidate statusbar");
+      DEBUG_ERROR_LOG(::GetLastError(), PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_INVALIDATE_STATUSBAR, "Class::Invalidate statusbar");
   }
 }
 
 
 void CPluginClass::Unadvice()
 {
   s_criticalSectionLocal.Lock();
   {
     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, L"Class::Unadvice - Unadvise");
+          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();
   {
     if (!s_hIcons[type])
     {
       s_hIcons[type] = ::LoadIcon(_Module.m_hInst, MAKEINTRESOURCE(s_hIconTypes[type]));
       if (!s_hIcons[type])
       {
-        DEBUG_ERROR_LOG(::GetLastError(), PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_LOAD_ICON, L"Class::GetIcon - LoadIcon")
+        DEBUG_ERROR_LOG(::GetLastError(), PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_LOAD_ICON, "Class::GetIcon - LoadIcon")
       }
     }
 
     icon = s_hIcons[type];
   }
   s_criticalSectionLocal.Unlock();
 
   return icon;
 }
 
 ATOM CPluginClass::GetAtomPaneClass()
 {
   return s_atomPaneClass;
 }
 
 HWND CPluginClass::GetTabHWND() const
 {
 
   TCHAR szClassName[MAX_PATH];
   // Get browser window and url
   HWND hBrowserWnd = GetBrowserHWND();
   if (!hBrowserWnd)
   {
-    DEBUG_ERROR_LOG(0, PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_NO_STATUSBAR_BROWSER, L"Class::GetTabWindow - No tab window")
+    DEBUG_ERROR_LOG(0, PLUGIN_ERROR_UI, PLUGIN_ERROR_UI_NO_STATUSBAR_BROWSER, "Class::GetTabWindow - No tab window")
       s_criticalSectionWindow.Unlock();
 
     return false;
   }
 
   // Looking for a TabWindowClass window in IE7
 
   HWND hTabWnd = ::GetWindow(hBrowserWnd, GW_CHILD);
   while (hTabWnd)
   {
@@ skipping 12 matching lines @@
       if (hTabWnd2)
       {
         DWORD nProcessId;
         ::GetWindowThreadProcessId(hTabWnd2, &nProcessId);
         if (::GetCurrentProcessId() == nProcessId)
         {
           bool bExistingTab = false;
           s_criticalSectionLocal.Lock();
 
           {
-            for (int i = 0; i < s_instances.GetSize(); i++)
+            for (auto instance : s_instances)
             {
-              if (s_instances[i]->m_hTabWnd == hTabWnd2)
+              if (instance->m_hTabWnd == hTabWnd2)
               {
                 bExistingTab = true;
                 break;
               }
             }
           }
 
           if (!bExistingTab)
           {
             hBrowserWnd = hTabWnd2;
             hTabWnd = hTabWnd2;
             s_criticalSectionLocal.Unlock();
             break;
           }
           s_criticalSectionLocal.Unlock();
 
         }
       }
     }
 
     hTabWnd = ::GetWindow(hTabWnd, GW_HWNDNEXT);
   }
 
   return hTabWnd;
 
 }