Issue #1173 - Default behavior for catch-all blocks

src/plugin/Exception.h

 /*
  * 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/>.
  */
 
 /** \file Exception.h -- Default behavior for catch-all exception handlers.
  */
 
-template<class SubHandlers>
+template<typename SubHandlers>
 struct CatchAllVoid
 {
-  static void Handler()
+  template<typename T>
+  static void Handler(T t = T())

[sergei, 2015/03/31 14:30:51]

Let's rename T to UserData and t to userData.

   {
     try
     {
       std::rethrow_exception(std::current_exception());
     }
     catch (std::system_error& ex)

[sergei, 2015/03/31 14:30:51]

We don't need non const references, so it is better to add const modifier to all
exceptions, the argument that we will need to change the helper classes in tests
(btw, which are just introduced) should not work.
I've added it in my change, no troubles.

[Eric, 2015/05/14 14:42:50]

Using 'const' here is overly restrictive. It requires the 'SubHandlers' members
to all be declared 'const'. There's no need to enforce it here in the template.

[sergei, 2015/05/15 13:13:24]

Yes, it's more restrictive and requires `SubHandlers` members to have exception
argument as a const reference (it's different from your version). It saves us
from any kind of mistakes at the compile time. If we ever need non-const
reference to exception in some new `SubHandlers` then we can remove `const` here
and continue to use old `SubHandlers`.
Can someone tell when we need non-const reference to the exception?

     {
-      SubHandlers::SystemError(ex);
+      SubHandlers::SystemError(ex, t);
     }
     catch (std::runtime_error& ex)
     {
-      SubHandlers::RuntimeError(ex);
+      SubHandlers::RuntimeError(ex, t);
     }
     catch (std::logic_error& ex)
     {
-      SubHandlers::LogicError(ex);
+      SubHandlers::LogicError(ex, t);
     }
     catch (std::exception& ex)
     {
-      SubHandlers::Exception(ex);
+      SubHandlers::Exception(ex, t);
     }
     catch (...)
     {
-      SubHandlers::Unknown();
+      SubHandlers::Unknown(t);
     }
   }
 };
 
-template<class SubHandlers, class ReturnType=SubHandlers::return_t>
+template<typename SubHandlers, typename ReturnType = typename SubHandlers::ReturnType>
 struct CatchAllReturn
 {
-  static ReturnType Handler()
+  template<typename T>
+  static ReturnType Handler(T t = T())
   {
     try
     {
       std::rethrow_exception(std::current_exception());
       // Apparently VS 2012 does not realize that this function always throws.
       // Unless we have an explicit return statement, we get a spurious warning C4715 "not all control paths return a value".
       return ReturnType();
     }
     catch (std::system_error& ex)
     {
-      return SubHandlers::SystemError(ex);
+      return SubHandlers::SystemError(ex, t);
     }
     catch (std::runtime_error& ex)
     {
-      return SubHandlers::RuntimeError(ex);
+      return SubHandlers::RuntimeError(ex, t);
     }
     catch (std::logic_error& ex)
     {
-      return SubHandlers::LogicError(ex);
+      return SubHandlers::LogicError(ex, t);
     }
     catch (std::exception& ex)
     {
-      return SubHandlers::Exception(ex);
+      return SubHandlers::Exception(ex, t);
     }
     catch (...)
     {
-      return SubHandlers::Unknown();
+      return SubHandlers::Unknown(t);
     }
   }
 };
-
-/*
- * NullHandlers is used at present to define the default exception behavior.
- * When we get non-trivial default exception behavior, this class can move into the unit tests.
- */
-struct NullHandlers
-{
-  static void Unknown() {}
-  static void Exception(std::exception& ex) {}
-  static void LogicError(std::logic_error& ex) { Exception(ex); }
-  static void RuntimeError(std::runtime_error& ex) { Exception(ex); }
-  static void SystemError(std::system_error& ex) { RuntimeError(ex); }
-};
-
-void DefaultExceptionBehavior()
-{
-  CatchAllVoid<NullHandlers>::Handler();
-}
-