First run page triggering

src/plugin/AdblockPlusClient.cpp

 #include "PluginStdAfx.h"
 
 #include "PluginSettings.h"
 #include "PluginSystem.h"
 #include "PluginFilter.h"
 #include "PluginClientFactory.h"
 #include "PluginMutex.h"
 #include "PluginClass.h"
 
 #include "AdblockPlusClient.h"
 
-#include "../shared/Communication.h"
 #include "../shared/Utils.h"
 
 namespace
 {
   void SpawnAdblockPlusEngine()
   {
     std::wstring engineExecutablePath = GetDllDir() + L"AdblockPlusEngine.exe";
     CString params = L"AdblockPlusEngine.exe " + CPluginSystem::GetInstance()->GetBrowserLanguage();
 
     STARTUPINFO startupInfo = {};
@@ skipping 74 matching lines @@
       description.title = ToUtf16String(title);
       std::string specialization;
       message >> specialization;
       description.specialization = ToUtf16String(specialization);
       message >> description.listed;
       result.push_back(description);
     }
     return result;
   }
 
-  Communication::InputBuffer CallAdblockPlusEngineProcedure(Communication::OutputBuffer& message)
-  {
-    std::auto_ptr<Communication::Pipe> pipe = OpenAdblockPlusEnginePipe();
-    pipe->WriteMessage(message);
-    return pipe->ReadMessage();
-  }
-
-  Communication::InputBuffer CallAdblockPlusEngineProcedure(Communication::ProcType proc)
+  bool CallEngine(Communication::OutputBuffer& message, Communication::InputBuffer* inputBuffer = NULL)
+  {
+    try
+    {
+      std::auto_ptr<Communication::Pipe> pipe = OpenAdblockPlusEnginePipe();
+      pipe->WriteMessage(message);
+      if (inputBuffer != NULL)
+      {
+        *inputBuffer = pipe->ReadMessage();
+      }
+      else
+      {
+        pipe->ReadMessage();
+      }
+    }
+    catch (const std::exception& e)
+    {
+      DEBUG_GENERAL(e.what());
+      return false;
+    }
+    return true;
+  }
+
+  bool CallEngine(Communication::ProcType proc, Communication::InputBuffer* inputBuffer = NULL)
   {
     Communication::OutputBuffer message;
     message << proc;
-    return CallAdblockPlusEngineProcedure(message);
+    return CallEngine(message, inputBuffer);
   }
 }
 
 CAdblockPlusClient* CAdblockPlusClient::s_instance = NULL;
 
 CAdblockPlusClient::CAdblockPlusClient() : CPluginClientBase()
 {
   m_filter = std::auto_ptr<CPluginFilter>(new CPluginFilter());
 }
 
@@ skipping 77 matching lines @@
   }
   m_criticalSectionFilter.Unlock();
   return isHidden;
 }
 
 bool CAdblockPlusClient::IsWhitelistedUrl(const std::wstring& url)
 {
   Communication::OutputBuffer request;
   request << Communication::PROC_IS_WHITELISTED_URL << ToUtf8String(url);
 
-  try
-  {
-    Communication::InputBuffer response = CallAdblockPlusEngineProcedure(request);
-
-    bool isWhitelisted;
-    response >> isWhitelisted;
-    return isWhitelisted;
-  }
-  catch (const std::exception& e)
-  {
-    DEBUG_GENERAL(e.what());
-    return false;
-  }
+  Communication::InputBuffer response;
+  if (!CallEngine(request, &response)) return false;;
+
+  bool isWhitelisted;
+  response >> isWhitelisted;
+  return isWhitelisted;
 }
 
 int CAdblockPlusClient::GetIEVersion()
 {
   //HKEY_LOCAL_MACHINE\Software\Microsoft\Internet Explorer
   HKEY hKey;
   LSTATUS status = RegOpenKey(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Internet Explorer", &hKey);
   if (status != 0)
   {
     return 0;
   }
   DWORD type, cbData;
   BYTE version[50];
   cbData = 50;
   status = RegQueryValueEx(hKey, L"Version", NULL, &type, (BYTE*)version, &cbData);
   if (status != 0)
   {
     return 0;
   }
   RegCloseKey(hKey);
   return (int)(version[0] - 48);
 }
 
 bool CAdblockPlusClient::Matches(const std::wstring& url, const std::wstring& contentType, const std::wstring& domain)
 {
   Communication::OutputBuffer request;
   request << Communication::PROC_MATCHES << ToUtf8String(url) << ToUtf8String(contentType) << ToUtf8String(domain);
 
-  try
-  {
-    Communication::InputBuffer response = CallAdblockPlusEngineProcedure(request);
-
-    bool match;
-    response >> match;
-    return match;
-  }
-  catch (const std::exception& e)
-  {
-    DEBUG_GENERAL(e.what());
-    return false;
-  }
+  Communication::InputBuffer response;
+  if (!CallEngine(request, &response)) return false;;
+
+  bool match;
+  response >> match;
+  return match;
 }
 
 std::vector<std::wstring> CAdblockPlusClient::GetElementHidingSelectors(const std::wstring& domain)
 {
   Communication::OutputBuffer request;
   request << Communication::PROC_GET_ELEMHIDE_SELECTORS << ToUtf8String(domain);
 
-  try
-  {
-    Communication::InputBuffer response = CallAdblockPlusEngineProcedure(request);
-    return ReadStrings(response);
-  }
-  catch (const std::exception& e)
-  {
-    DEBUG_GENERAL(e.what());
-    return std::vector<std::wstring>();
-  }
+  Communication::InputBuffer response;
+  if (!CallEngine(request, &response)) return std::vector<std::wstring>();
+  return ReadStrings(response);
 }
 
 std::vector<SubscriptionDescription> CAdblockPlusClient::FetchAvailableSubscriptions()
 {
-  try
-  {
-    Communication::InputBuffer response = CallAdblockPlusEngineProcedure(Communication::PROC_AVAILABLE_SUBSCRIPTIONS);
-    return ReadSubscriptions(response);
-  }
-  catch (const std::exception& e)
-  {
-    DEBUG_GENERAL(e.what());
-    return std::vector<SubscriptionDescription>();
-  }
+  Communication::InputBuffer response;
+  if (!CallEngine(Communication::PROC_AVAILABLE_SUBSCRIPTIONS, &response)) return std::vector<SubscriptionDescription>();
+  return ReadSubscriptions(response);
 }
 
 std::vector<SubscriptionDescription> CAdblockPlusClient::GetListedSubscriptions()
 {
-  try
-  {
-    Communication::InputBuffer response = CallAdblockPlusEngineProcedure(Communication::PROC_LISTED_SUBSCRIPTIONS);
-    return ReadSubscriptions(response);
-  }
-  catch (const std::exception& e)
-  {
-    DEBUG_GENERAL(e.what());
-    return std::vector<SubscriptionDescription>();
-  }
+  Communication::InputBuffer response;
+  if (!CallEngine(Communication::PROC_LISTED_SUBSCRIPTIONS, &response)) return std::vector<SubscriptionDescription>();
+  return ReadSubscriptions(response);
 }
 
 void CAdblockPlusClient::SetSubscription(const std::wstring& url)
 {
   Communication::OutputBuffer request;
   request << Communication::PROC_SET_SUBSCRIPTION << ToUtf8String(url);
-
-  try
-  {
-    CallAdblockPlusEngineProcedure(request);
-  }
-  catch (const std::exception& e)
-  {
-    DEBUG_GENERAL(e.what());
-  }
+  CallEngine(request);
 }
 
 void CAdblockPlusClient::UpdateAllSubscriptions()
 {
-  try
-  {
-    CallAdblockPlusEngineProcedure(Communication::PROC_UPDATE_ALL_SUBSCRIPTIONS);
-  }
-  catch (const std::exception& e)
-  {
-    DEBUG_GENERAL(e.what());
-  }
+  CallEngine(Communication::PROC_UPDATE_ALL_SUBSCRIPTIONS);
 }
 
 std::vector<std::wstring> CAdblockPlusClient::GetExceptionDomains()
 {
-  try
-  {
-    Communication::InputBuffer response = CallAdblockPlusEngineProcedure(Communication::PROC_GET_EXCEPTION_DOMAINS);
-    return ReadStrings(response);
-  }
-  catch (const std::exception& e)
-  {
-    DEBUG_GENERAL(e.what());
-    return std::vector<std::wstring>();
-  }
-}
-
+  Communication::InputBuffer response;
+  if (!CallEngine(Communication::PROC_GET_EXCEPTION_DOMAINS)) return std::vector<std::wstring>();
+  return ReadStrings(response);
+}
+
+bool CAdblockPlusClient::IsFirstRun()
+{
+  Communication::InputBuffer response;
+  if (!CallEngine(Communication::PROC_IS_FIRST_RUN_ACTION_NEEDED, &response)) return false;
+  bool res;
+  response >> res;
+  return res;
+}
 void CAdblockPlusClient::AddFilter(const std::wstring& text)
 {
   Communication::OutputBuffer request;
   request << Communication::PROC_ADD_FILTER << ToUtf8String(text);
-
-  try
-  {
-    CallAdblockPlusEngineProcedure(request);
-  }
-  catch (const std::exception& e)
-  {
-    DEBUG_GENERAL(e.what());
-  }
+  CallEngine(request);
 }
 
 void CAdblockPlusClient::RemoveFilter(const std::wstring& text)
 {
   Communication::OutputBuffer request;
   request << Communication::PROC_REMOVE_FILTER << ToUtf8String(text);
-
-  try
-  {
-    CallAdblockPlusEngineProcedure(request);
-  }
-  catch (const std::exception& e)
-  {
-    DEBUG_GENERAL(e.what());
-  }
+  CallEngine(request);
 }
 
 void CAdblockPlusClient::SetPref(const std::wstring& name, const std::wstring& value)
 {
   Communication::OutputBuffer request;
   request << Communication::PROC_SET_PREF << ToUtf8String(name) << ToUtf8String(value);
-
-  try
-  {
-    CallAdblockPlusEngineProcedure(request);
-  }
-  catch (const std::exception& e)
-  {
-    DEBUG_GENERAL(e.what());
-  }
-}
-
-std::wstring CAdblockPlusClient::GetPref(const std::wstring& name)
+  CallEngine(request);
+}
+
+void CAdblockPlusClient::SetPref(const std::wstring& name, const int64_t & value)
+{
+  Communication::OutputBuffer request;
+  request << Communication::PROC_SET_PREF << ToUtf8String(name) << value;
+  CallEngine(request);
+}
+
+void CAdblockPlusClient::SetPref(const std::wstring& name, bool value)
+{
+  Communication::OutputBuffer request;
+  request << Communication::PROC_SET_PREF << ToUtf8String(name) << value;
+  CallEngine(request);
+}
+
+std::wstring CAdblockPlusClient::GetPref(const std::wstring& name, const wchar_t* defaultValue)
+{
+  return GetPref(name, std::wstring(defaultValue));
+}
+std::wstring CAdblockPlusClient::GetPref(const std::wstring& name, const std::wstring& defaultValue)
 {
   Communication::OutputBuffer request;
   request << Communication::PROC_GET_PREF << ToUtf8String(name);
 
-  try
-  {
-    Communication::InputBuffer response = CallAdblockPlusEngineProcedure(request);
-    std::vector<std::wstring> retValue = ReadStrings(response);
-    return retValue.size() > 0 ? retValue.at(0) : L"";
-  }
-  catch (const std::exception& e)
-  {
-    DEBUG_GENERAL(e.what());
-    return L"";
-  }
-}
-
-bool CAdblockPlusClient::GetIsFirstRun()

[Wladimir Palant, 2013/07/11 11:58:10]

CAdblockPlusClient::IsFirstRun() should be a better name - you are querying a
flag here. Same applies to the call name, should be
Communication::PROC_IS_FIRST_RUN.

-{
-  Communication::OutputBuffer request;
-  request << Communication::PROC_GET_IS_FIRST_RUN;
-  try
-  {
-    Communication::InputBuffer response = CallAdblockPlusEngineProcedure(request);

[Wladimir Palant, 2013/07/11 11:58:10]

CallAdblockPlusEngineProcedure(Communication::PROC_GET_IS_FIRST_RUN) will do
here, no need to fill OutputBuffer explicitly here.

-    bool res = false;

[Wladimir Palant, 2013/07/11 11:58:10]

Please don't initialize that variable, its initial value is ignored and
overwritten one line below.

-    response >> res;
-    return res;
-  }
-  catch (const std::exception& e)
-  {
-    DEBUG_GENERAL(e.what());
-  }
-  return false;
-}
+  Communication::InputBuffer response;
+  if (!CallEngine(request, &response)) return defaultValue;
+  bool success;
+  response >> success;
+  if (success)
+  {
+    std::string value;
+    response >> value;
+    return ToUtf16String(value);
+  }
+  else
+    return defaultValue;
+}
+
+bool CAdblockPlusClient::GetPref(const std::wstring& name, bool defaultValue)
+{
+  Communication::OutputBuffer request;
+  request << Communication::PROC_GET_PREF << ToUtf8String(name);
+
+  Communication::InputBuffer response;
+  if (!CallEngine(request, &response)) return defaultValue;
+  bool success;
+  response >> success;
+  if (success)
+  {
+    bool value;
+    response >> value;
+    return value;
+  }
+  else
+    return defaultValue;
+}
+int64_t CAdblockPlusClient::GetPref(const std::wstring& name, int64_t defaultValue)
+{
+  Communication::OutputBuffer request;
+  request << Communication::PROC_GET_PREF << ToUtf8String(name);
+
+  Communication::InputBuffer response;
+  if (!CallEngine(request, &response)) return defaultValue;
+    bool success;
+  response >> success;
+  if (success)
+  {
+    int64_t value;
+    response >> value;
+    return value;
+  }
+  else
+    return defaultValue;
+}