Playing with Default behavior for catch-all blocks

src/plugin/PluginDebug.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 "PluginDebug.h"
+#include "Exception.h"
 #include "PluginMutex.h"
 #include "PluginSettings.h"
 
+#if (defined ENABLE_DEBUG_INFO)
+namespace {
+  // VS 2012 does not have support for variadic templates, which would eliminate the need for an argument class.
+  struct LogHandlersArguments
+  {
+    bool isEntryPoint;
+    std::string name;
+  };
+
+  std::string DefaultLogMessage(const LogHandlersArguments& x, const std::string &exceptionType)
+  {
+    std::string s = x.isEntryPoint ? "ENTRY POINT '" : "'";
+    s += x.name;
+    s += "' caught default ";
+    s += exceptionType;
+    return s;
+  }
+
+  struct LogHandlers
+  {
+    static void Unknown(const LogHandlersArguments& args)
+    {
+      CPluginDebug::Debug(DefaultLogMessage(args, "Unknown exception"));
+    }
+    static void Exception(const std::exception& ex, LogHandlersArguments& args)
+    {
+      CPluginDebug::DebugOrdinaryException(ex,
+        PLUGIN_ERROR_ENTRY_POINT, PLUGIN_ERROR_ENTRY_POINT_CATCHALL_EXCEPTION,
+        DefaultLogMessage(args, "std::exception"));
+    }
+    static void LogicError(const std::logic_error& ex, LogHandlersArguments& args)
+    {
+      CPluginDebug::DebugOrdinaryException(ex,
+        PLUGIN_ERROR_ENTRY_POINT, PLUGIN_ERROR_ENTRY_POINT_CATCHALL_EXCEPTION,
+        DefaultLogMessage(args, "std::logic_error"));
+    }
+    static void RuntimeError(const std::runtime_error& ex, LogHandlersArguments& args)
+    {
+      CPluginDebug::DebugOrdinaryException(ex,
+        PLUGIN_ERROR_ENTRY_POINT, PLUGIN_ERROR_ENTRY_POINT_CATCHALL_EXCEPTION,
+        DefaultLogMessage(args, "std::runtime_error"));
+    }
+    static void SystemError(const std::system_error& ex, LogHandlersArguments& args)
+    {
+      CPluginDebug::DebugSystemException(ex,
+        PLUGIN_ERROR_ENTRY_POINT, PLUGIN_ERROR_ENTRY_POINT_CATCHALL_EXCEPTION,
+        DefaultLogMessage(args, "std::std::system_error"));
+    }
+  };
+}
+#endif
+
+void EntryPointExceptionDefault(const std::string& name)
+{
+#if (defined ENABLE_DEBUG_INFO)
+  // VS 2012 does not have support for brace initializer lists; otherwise this could be a single line
+  LogHandlersArguments x;
+  x.isEntryPoint = true;
+  x.name = name;
+  CatchAllVoid<LogHandlers>::Handler(x);
+#endif
+}
+
+void ExceptionDefault(const std::string& name)
+{
+#if (defined ENABLE_DEBUG_INFO)
+  LogHandlersArguments x;
+  x.isEntryPoint = false;
+  x.name = name;
+  CatchAllVoid<LogHandlers>::Handler(x);
+#endif
+}
+
 class CPluginDebugLock : public CPluginMutex
 {
 
 private:
 
   static CComAutoCriticalSection s_criticalSectionDebugLock;
 
 public:
 
   CPluginDebugLock() : CPluginMutex(L"DebugFile", PLUGIN_ERROR_MUTEX_DEBUG_FILE)
   {
     s_criticalSectionDebugLock.Lock();
   }
 
   ~CPluginDebugLock()
   {
     s_criticalSectionDebugLock.Unlock();
   }
 };
 
 CComAutoCriticalSection CPluginDebugLock::s_criticalSectionDebugLock;
 
 void CPluginDebug::DebugSystemException(const std::system_error& ex, int errorId, int errorSubid, const std::string& description)
 {
   std::string message = description + ", " + ex.code().message() + ", " + ex.what();
   DEBUG_ERROR_LOG(ex.code().value(), errorId, errorSubid, message);
 }
 
+void CPluginDebug::DebugOrdinaryException(const std::exception& ex, int errorId, int errorSubid, const std::string& description)
+{
+  std::string message = description + ", " + ex.what();
+  DEBUG_ERROR_LOG(0, errorId, errorSubid, message);
+}
+
 #ifdef ENABLE_DEBUG_INFO
 
 void DebugLegacy(const CString& text, DWORD dwProcessId, DWORD dwThreadId)
 {
 #ifdef USE_CONSOLE
   CONSOLE("%s", CT2A(text.GetString(), CP_UTF8));
 #endif
 
   if (CPluginSettings::HasInstance())
   {
@@ skipping 187 matching lines @@
     srcTrunc = srcTrunc.Left(67) + L"..." + srcTrunc.Right(30);
   }
 
   CString blocking;
   blocking.Format(L"Ignored  %-12s  %s  %s", ToCString(type), domain.empty()? L"-" : ToCString(domain), srcTrunc);
 
   DebugResultLegacy(blocking);
 }
 
 #endif // ENABLE_DEBUG_RESULT_IGNORED