[IE] First round of ATL removal

src/plugin/PluginSettings.cpp

 #include "PluginStdAfx.h"
 
 #include <Wbemidl.h>
 #include <time.h>
 #include "PluginSettings.h"
 #include "PluginClient.h"
 #include "PluginSystem.h"
 #ifdef SUPPORT_FILTER
 #include "PluginFilter.h"
 #endif
 #include "PluginMutex.h"
 #include "../shared/Utils.h"
 #include <memory>
 
 
 // IE functions
 #pragma comment(lib, "iepmapi.lib")
 
 #include <knownfolders.h>
 
 namespace
 {
-  std::wstring CreateDomainWhitelistingFilter(const CString domain)
+  std::wstring CreateDomainWhitelistingFilter(const std::wstring domain)
   {
-    return std::wstring(L"@@||") + domain.GetString() + std::wstring(L"^$document");
+    return L"@@||" + domain + L"^$document";
   }
 }
 
 class TSettings
 {
   DWORD processorId;
 
   char sPluginId[44];
 };
 
 
 class CPluginSettingsLock : public CPluginMutex
 {
 public:
-  CPluginSettingsLock() : CPluginMutex("SettingsFile", PLUGIN_ERROR_MUTEX_SETTINGS_FILE) {}
+  CPluginSettingsLock() : CPluginMutex( L"SettingsFile", PLUGIN_ERROR_MUTEX_SETTINGS_FILE ) {}
   ~CPluginSettingsLock() {}
 
 };
 
 
 class CPluginSettingsTabLock : public CPluginMutex
 {
 public:
-  CPluginSettingsTabLock() : CPluginMutex("SettingsFileTab", PLUGIN_ERROR_MUTEX_SETTINGS_FILE_TAB) {}
+  CPluginSettingsTabLock() : CPluginMutex( L"SettingsFileTab", PLUGIN_ERROR_MUTEX_SETTINGS_FILE_TAB ) {}
   ~CPluginSettingsTabLock() {}
 };
 
 #ifdef SUPPORT_WHITELIST
 
 class CPluginSettingsWhitelistLock : public CPluginMutex
 {
 public:
-  CPluginSettingsWhitelistLock() : CPluginMutex("SettingsFileWhitelist", PLUGIN_ERROR_MUTEX_SETTINGS_FILE_WHITELIST) {}
+  CPluginSettingsWhitelistLock() : CPluginMutex( L"SettingsFileWhitelist", PLUGIN_ERROR_MUTEX_SETTINGS_FILE_WHITELIST ) {}
   ~CPluginSettingsWhitelistLock() {}
 };
 
 #endif
 
 CPluginSettings* CPluginSettings::s_instance = NULL;
 
 CComAutoCriticalSection CPluginSettings::s_criticalSectionLocal;
 
 
@@ skipping 40 matching lines @@
 
   s_criticalSectionLocal.Lock();
   {
     hasInstance = s_instance != NULL;
   }
   s_criticalSectionLocal.Unlock();
 
   return hasInstance;
 }
 
-
-
-CString CPluginSettings::GetDataPath(const CString& filename)
+std::wstring CPluginSettings::GetDataPath(const std::wstring & filename)
 {
-  std::wstring path = ::GetAppDataPath() + L"\\" + static_cast<LPCWSTR>(filename);
-  return CString(path.c_str());
+  return ::GetAppDataPath() + L"\\" + filename;
 }
 
-CString CPluginSettings::GetSystemLanguage()
+std::wstring CPluginSettings::GetSystemLanguage()
 {
-  CString language;
-  CString country;
+  DWORD bufSize = 256;
+  std::unique_ptr< wchar_t > buffer( new wchar_t[ bufSize ] );
+  int ccBuf = GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SISO639LANGNAME, buffer.get(), bufSize);
+  std::wstring language( buffer.get() );
+  ccBuf = GetLocaleInfoW(LOCALE_SYSTEM_DEFAULT, LOCALE_SISO3166CTRYNAME, buffer.get(), bufSize);
+  std::wstring country( buffer.get() );
 
-  DWORD bufSize = 256;
-  int ccBuf = GetLocaleInfo(LOCALE_SYSTEM_DEFAULT, LOCALE_SISO639LANGNAME, language.GetBufferSetLength(bufSize), bufSize);
-  ccBuf = GetLocaleInfo(LOCALE_SYSTEM_DEFAULT, LOCALE_SISO3166CTRYNAME, country.GetBufferSetLength(bufSize), bufSize);
-
-  if ((country.IsEmpty()) || (language.IsEmpty()))
+  if ((country.empty()) || (language.empty()))
   {
-    return CString();
+    return L"";
   }
-  CString lang;
-  lang.Append(language);
-  lang.Append(L"-");
-  lang.Append(country);
-
-  return lang;
-
+  return language + L"-" + country;
 }
 
 
 bool CPluginSettings::IsPluginEnabled() const
 {
   return GetPluginEnabled();
 }
 
 
-std::map<CString, CString> CPluginSettings::GetFilterLanguageTitleList() const
+std::map< std::wstring, std::wstring > CPluginSettings::GetFilterLanguageTitleList() const
 {
   std::vector<SubscriptionDescription> subscriptions = CPluginClient::GetInstance()->FetchAvailableSubscriptions();
 
-  std::map<CString, CString> filterList;
+  std::map< std::wstring, std::wstring > filterList;
   for (size_t i = 0; i < subscriptions.size(); i ++)
   {
     SubscriptionDescription it = subscriptions[i];
-    filterList.insert(std::make_pair(CString(it.url.c_str()), CString(it.title.c_str())));
+    filterList.insert(std::make_pair(it.url, it.title));
   }
   return filterList;
 }
 
 bool CPluginSettings::IsWorkingThread(DWORD dwThreadId) const
 {
   if (dwThreadId == 0)
   {
     dwThreadId = ::GetCurrentThreadId();
   }
@@ skipping 13 matching lines @@
 void CPluginSettings::TogglePluginEnabled()
 {
   CPluginClient::GetInstance()->TogglePluginEnabled();  
 }
 bool CPluginSettings::GetPluginEnabled() const
 {
   return CPluginClient::GetInstance()->GetPref(L"enabled", true);
 }
 
 
-void CPluginSettings::AddError(const CString& error, const CString& errorCode)
+void CPluginSettings::AddError(const std::wstring & error, const std::wstring & errorCode)
 {
-  DEBUG_SETTINGS(L"SettingsTab::AddError error:" + error + " code:" + errorCode)
+  DEBUG_SETTINGS( L"SettingsTab::AddError error:" + error + L" code:" + errorCode )
 }
 
 
 // ============================================================================
 // Whitelist settings
 // ============================================================================
 
 #ifdef SUPPORT_WHITELIST
 
 void CPluginSettings::ClearWhitelist()
 {
   s_criticalSectionLocal.Lock();
   {
     m_whitelistedDomains.clear();
   }
   s_criticalSectionLocal.Unlock();
 }
 
 
 bool CPluginSettings::ReadWhitelist(bool isDebug)
 {
   bool isRead = true;
 
   DEBUG_SETTINGS("SettingsWhitelist::Read")
 
     if (isDebug)
     {
-      DEBUG_GENERAL("*** Loading whitelist settings");
+      DEBUG_GENERAL(L"*** Loading whitelist settings");
     }
 
     CPluginSettingsWhitelistLock lock;
     if (lock.IsLocked())
     {
       ClearWhitelist();
 
       s_criticalSectionLocal.Lock();
       m_whitelistedDomains = CPluginClient::GetInstance()->GetExceptionDomains();
       s_criticalSectionLocal.Unlock();
     }
     else
     {
       isRead = false;
     }
 
     return isRead;
 }
 
 
-void CPluginSettings::AddWhiteListedDomain(const CString& domain)
+void CPluginSettings::AddWhiteListedDomain(const std::wstring & domain)
 {
   DEBUG_SETTINGS("SettingsWhitelist::AddWhiteListedDomain domain:" + domain)
   CPluginClient::GetInstance()->AddFilter(CreateDomainWhitelistingFilter(domain));
 }
 
-void CPluginSettings::RemoveWhiteListedDomain(const CString& domain)
+void CPluginSettings::RemoveWhiteListedDomain(const std::wstring & domain)
 {
   DEBUG_SETTINGS("SettingsWhitelist::RemoveWhiteListedDomain domain:" + domain)
   CPluginClient::GetInstance()->RemoveFilter(CreateDomainWhitelistingFilter(domain));
 }
 
 int CPluginSettings::GetWhiteListedDomainCount() const
 {
   int count = 0;
 
   s_criticalSectionLocal.Lock();
@@ skipping 43 matching lines @@
 
   return m_WindowsBuildNumber;
 }
 
 void CPluginSettings::SetSubscription(const std::wstring& url)
 {
   CPluginClient::GetInstance()->SetSubscription(url);
   RefreshWhitelist();
 }
 
-CString CPluginSettings::GetSubscription()
+std::wstring CPluginSettings::GetSubscription()
 {
   std::vector<SubscriptionDescription> subscriptions = CPluginClient::GetInstance()->GetListedSubscriptions();
   if (subscriptions.size() > 0)
-    return CString(subscriptions.front().url.c_str());
+    return subscriptions.front().url;
   else
-    return CString(L"");
+    return L"";
 }
 
-CString CPluginSettings::GetAppLocale()
+std::wstring CPluginSettings::GetAppLocale()
 {
   return CPluginSystem::GetInstance()->GetBrowserLanguage();
 }
 
-CString CPluginSettings::GetDocumentationLink()
+std::wstring CPluginSettings::GetDocumentationLink()
 {
-  return CString(CPluginClient::GetInstance()->GetDocumentationLink().c_str());
+  return CPluginClient::GetInstance()->GetDocumentationLink();
 }
 
 
 
 #endif // SUPPORT_WHITELIST