Issue #1234 - Convert strings associated with URL's

src/plugin/PluginTabBase.cpp

 #include "PluginStdAfx.h"
 
 #include "PluginClient.h"
 #include "PluginSettings.h"
 #include "PluginTab.h"
 #include "AdblockPlusDomTraverser.h"
 #include "PluginClass.h"
 #include "PluginTabBase.h"
 #include "PluginUtil.h"
 #include <dispex.h>
@@ skipping 55 matching lines @@
 
 namespace
 {
   void FilterLoader(CPluginTabBase* tabBase)
   {
     tabBase->m_filter->LoadHideFilters(CPluginClient::GetInstance()->GetElementHidingSelectors(tabBase->GetDocumentDomain()));
     SetEvent(tabBase->m_filter->hideFiltersLoadedEvent);
   }
 }
 
-void CPluginTabBase::OnNavigate(const CString& url)
+void CPluginTabBase::OnNavigate(const std::wstring& url)
 {
   SetDocumentUrl(url);
   ClearFrameCache(GetDocumentDomain());
   std::wstring domainString = GetDocumentDomain();
   ResetEvent(m_filter->hideFiltersLoadedEvent);
   try
   {
     std::thread filterLoaderThread(&FilterLoader, this);
     filterLoaderThread.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 start filter loader thread, ") +
       ex.code().message() + ex.what();
     DEBUG_ERROR_LOG(ex.code().value(), PLUGIN_ERROR_THREAD, PLUGIN_ERROR_MAIN_THREAD_CREATE_PROCESS, errDescription.c_str());
   }
   m_traverser->ClearCache();
 }
 
 void CPluginTabBase::InjectABP(IWebBrowser2* browser)
 {
   CriticalSection::Lock lock(m_csInject);
-  CString url = GetDocumentUrl();
+  CString url = ToCString(GetDocumentUrl());
   CString log;
   log.Format(L"InjectABP. Current URL: %s, settings URL: %s", url, UserSettingsFileUrl().c_str());
   DEBUG_GENERAL(log);
   if (!(0 == url.CompareNoCase(CString(UserSettingsFileUrl().c_str())) ||
       0 == url.CompareNoCase(CString(FirstRunPageFileUrl().c_str()))))
   {
     DEBUG_GENERAL(L"Not injecting");
     return;
   }
   DEBUG_GENERAL(L"Going to inject");
@@ skipping 40 matching lines @@
   DEBUG_GENERAL("Invoke");
   if (FAILED(hr))
   {
     DEBUG_ERROR_LOG(hr, PLUGIN_ERROR_CREATE_SETTINGS_JAVASCRIPT, PLUGIN_ERROR_CREATE_SETTINGS_JAVASCRIPT_INVOKE, "CPluginTabBase::InjectABP - Failed to create Settings in JavaScript");
   }
 }
 
 void CPluginTabBase::OnDownloadComplete(IWebBrowser2* browser)
 {
   CPluginClient* client = CPluginClient::GetInstance();
-  std::wstring url = to_wstring(GetDocumentUrl());
+  std::wstring url = GetDocumentUrl();
   if (!client->IsWhitelistedUrl(url) && !client->IsElemhideWhitelistedOnDomain(url))
   {
     m_traverser->TraverseDocument(browser, GetDocumentDomain(), GetDocumentUrl());
   }
   InjectABP(browser);
 }
 
-void CPluginTabBase::OnDocumentComplete(IWebBrowser2* browser, const CString& url, bool isDocumentBrowser)
+void CPluginTabBase::OnDocumentComplete(IWebBrowser2* browser, const std::wstring& url, bool isDocumentBrowser)
 {
-  CString documentUrl = GetDocumentUrl();
+  std::wstring documentUrl = GetDocumentUrl();
 
   if (isDocumentBrowser)
   {
     if (url != documentUrl)
     {
       SetDocumentUrl(url);
     }
     InjectABP(browser);
   }
-  if (url.Left(6) != "res://")
+  CString urlLegacy = ToCString(url);
+  if (urlLegacy.Left(6) != "res://")
   {
     // Get document
     CComPtr<IDispatch> pDocDispatch;
     HRESULT hr = browser->get_Document(&pDocDispatch);
     if (FAILED(hr) || !pDocDispatch)
     {
       return;
     }
 
     CComQIPtr<IHTMLDocument2> pDoc = pDocDispatch;
@@ skipping 26 matching lines @@
 
   m_criticalSection.Lock();
   {
     domain = m_documentDomain;
   }
   m_criticalSection.Unlock();
 
   return domain;
 }
 
-void CPluginTabBase::SetDocumentUrl(const CString& url)
+void CPluginTabBase::SetDocumentUrl(const std::wstring& url)
 {
   m_criticalSection.Lock();
   {
     m_documentUrl = url;
-    m_documentDomain = CAdblockPlusClient::GetInstance()->GetHostFromUrl(to_wstring(url));
+    m_documentDomain = CAdblockPlusClient::GetInstance()->GetHostFromUrl(url);
   }
   m_criticalSection.Unlock();
 }
 
-CString CPluginTabBase::GetDocumentUrl()
+std::wstring CPluginTabBase::GetDocumentUrl()
 {
-  CString url;
+  std::wstring url;
 
   m_criticalSection.Lock();
   {
     url = m_documentUrl;
   }
   m_criticalSection.Unlock();
 
   return url;
 }
 
 
 // ============================================================================
 // Frame caching
 // ============================================================================
-bool CPluginTabBase::IsFrameCached(const CString& url)
+bool CPluginTabBase::IsFrameCached(const std::wstring& url)
 {
   bool isFrame;
 
   m_criticalSectionCache.Lock();
   {
     isFrame = m_cacheFrames.find(url) != m_cacheFrames.end();
   }
   m_criticalSectionCache.Unlock();
 
   return isFrame;
 }
 
-void CPluginTabBase::CacheFrame(const CString& url)
+void CPluginTabBase::CacheFrame(const std::wstring& url)
 {
   m_criticalSectionCache.Lock();
   {
     m_cacheFrames.insert(url);
   }
   m_criticalSectionCache.Unlock();
 }
 
 void CPluginTabBase::ClearFrameCache(const std::wstring& domain)
 {
@@ skipping 69 matching lines @@
           CPluginClient::LogPluginError(pluginError.GetErrorCode(), pluginError.GetErrorId(), pluginError.GetErrorSubid(), pluginError.GetErrorDescription(), true, pluginError.GetProcessId(), pluginError.GetThreadId());
         }
 
         // Non-hanging sleep
         Sleep(50);
       }
 
       tabLoopIteration++;
   }
 }