Run clang-format on sigslot.h.

webrtc/base/sigslot.h

Index: webrtc/base/sigslot.h
diff --git a/webrtc/base/sigslot.h b/webrtc/base/sigslot.h
index c0fe5050fe2b2394c7762053cbad541b6bd2e754..4649f516137e2fefdc8357933238f98e167aeada 100644
--- a/webrtc/base/sigslot.h
+++ b/webrtc/base/sigslot.h
@@ -2,79 +2,88 @@
 //
 // Written by Sarah Thompson (sarah@telergy.com) 2002.
 //
-// License: Public domain. You are free to use this code however you like, with the proviso that
-//          the author takes on no responsibility or liability for any use.
+// License: Public domain. You are free to use this code however you like, with
+// the proviso that the author takes on no responsibility or liability for any
+// use.
 //
 // QUICK DOCUMENTATION
 //
-//				(see also the full documentation at http://sigslot.sourceforge.net/)
+//        (see also the full documentation at http://sigslot.sourceforge.net/)
 //
-//		#define switches
-//			SIGSLOT_PURE_ISO			- Define this to force ISO C++ compliance. This also disables
-//										  all of the thread safety support on platforms where it is
-//										  available.
+//    #define switches
+//      SIGSLOT_PURE_ISO:
+//        Define this to force ISO C++ compliance. This also disables all of
+//        the thread safety support on platforms where it is available.
 //
-//			SIGSLOT_USE_POSIX_THREADS	- Force use of Posix threads when using a C++ compiler other than
-//										  gcc on a platform that supports Posix threads. (When using gcc,
-//										  this is the default - use SIGSLOT_PURE_ISO to disable this if
-//										  necessary)
+//      SIGSLOT_USE_POSIX_THREADS:
+//        Force use of Posix threads when using a C++ compiler other than gcc
+//        on a platform that supports Posix threads. (When using gcc, this is
+//        the default - use SIGSLOT_PURE_ISO to disable this if necessary)
 //
-//			SIGSLOT_DEFAULT_MT_POLICY	- Where thread support is enabled, this defaults to multi_threaded_global.
-//										  Otherwise, the default is single_threaded. #define this yourself to
-//										  override the default. In pure ISO mode, anything other than
-//										  single_threaded will cause a compiler error.
+//      SIGSLOT_DEFAULT_MT_POLICY:
+//        Where thread support is enabled, this defaults to
+//        multi_threaded_global. Otherwise, the default is single_threaded.
+//        #define this yourself to override the default. In pure ISO mode,
+//        anything other than single_threaded will cause a compiler error.
 //
-//		PLATFORM NOTES
+//    PLATFORM NOTES
 //
-//			Win32						- On Win32, the WEBRTC_WIN symbol must be #defined. Most mainstream
-//										  compilers do this by default, but you may need to define it
-//										  yourself if your build environment is less standard. This causes
-//										  the Win32 thread support to be compiled in and used automatically.
+//      Win32:
+//        On Win32, the WEBRTC_WIN symbol must be #defined. Most mainstream
+//        compilers do this by default, but you may need to define it yourself
+//        if your build environment is less standard. This causes the Win32
+//        thread support to be compiled in and used automatically.
 //
-//			Unix/Linux/BSD, etc.		- If you're using gcc, it is assumed that you have Posix threads
-//										  available, so they are used automatically. You can override this
-//										  (as under Windows) with the SIGSLOT_PURE_ISO switch. If you're using
-//										  something other than gcc but still want to use Posix threads, you
-//										  need to #define SIGSLOT_USE_POSIX_THREADS.
+//      Unix/Linux/BSD, etc.:
+//        If you're using gcc, it is assumed that you have Posix threads
+//        available, so they are used automatically. You can override this (as
+//        under Windows) with the SIGSLOT_PURE_ISO switch. If you're using
+//        something other than gcc but still want to use Posix threads, you
+//        need to #define SIGSLOT_USE_POSIX_THREADS.
 //
-//			ISO C++						- If none of the supported platforms are detected, or if
-//										  SIGSLOT_PURE_ISO is defined, all multithreading support is turned off,
-//										  along with any code that might cause a pure ISO C++ environment to
-//										  complain. Before you ask, gcc -ansi -pedantic won't compile this
-//										  library, but gcc -ansi is fine. Pedantic mode seems to throw a lot of
-//										  errors that aren't really there. If you feel like investigating this,
-//										  please contact the author.
+//      ISO C++:
+//        If none of the supported platforms are detected, or if
+//        SIGSLOT_PURE_ISO is defined, all multithreading support is turned
+//        off, along with any code that might cause a pure ISO C++ environment
+//        to complain. Before you ask, gcc -ansi -pedantic won't compile this
+//        library, but gcc -ansi is fine. Pedantic mode seems to throw a lot of
+//        errors that aren't really there. If you feel like investigating this,
+//        please contact the author.
 //
 //
-//		THREADING MODES
+//    THREADING MODES
 //
-//			single_threaded				- Your program is assumed to be single threaded from the point of view
-//										  of signal/slot usage (i.e. all objects using signals and slots are
-//										  created and destroyed from a single thread). Behaviour if objects are
-//										  destroyed concurrently is undefined (i.e. you'll get the occasional
-//										  segmentation fault/memory exception).
+//      single_threaded:
+//        Your program is assumed to be single threaded from the point of view
+//        of signal/slot usage (i.e. all objects using signals and slots are
+//        created and destroyed from a single thread). Behaviour if objects are
+//        destroyed concurrently is undefined (i.e. you'll get the occasional
+//        segmentation fault/memory exception).
 //
-//			multi_threaded_global		- Your program is assumed to be multi threaded. Objects using signals and
-//										  slots can be safely created and destroyed from any thread, even when
-//										  connections exist. In multi_threaded_global mode, this is achieved by a
-//										  single global mutex (actually a critical section on Windows because they
-//										  are faster). This option uses less OS resources, but results in more
-//										  opportunities for contention, possibly resulting in more context switches
-//										  than are strictly necessary.
+//      multi_threaded_global:
+//        Your program is assumed to be multi threaded. Objects using signals
+//        and slots can be safely created and destroyed from any thread, even
+//        when connections exist. In multi_threaded_global mode, this is
+//        achieved by a single global mutex (actually a critical section on
+//        Windows because they are faster). This option uses less OS resources,
+//        but results in more opportunities for contention, possibly resulting
+//        in more context switches than are strictly necessary.
 //
-//			multi_threaded_local		- Behaviour in this mode is essentially the same as multi_threaded_global,
-//										  except that each signal, and each object that inherits has_slots, all
-//										  have their own mutex/critical section. In practice, this means that
-//										  mutex collisions (and hence context switches) only happen if they are
-//										  absolutely essential. However, on some platforms, creating a lot of
-//										  mutexes can slow down the whole OS, so use this option with care.
+//      multi_threaded_local:
+//        Behaviour in this mode is essentially the same as
+//        multi_threaded_global, except that each signal, and each object that
+//        inherits has_slots, all have their own mutex/critical section. In
+//        practice, this means that mutex collisions (and hence context
+//        switches) only happen if they are absolutely essential. However, on
+//        some platforms, creating a lot of mutexes can slow down the whole OS,
+//        so use this option with care.
 //
-//		USING THE LIBRARY
-//
-//			See the full documentation at http://sigslot.sourceforge.net/
+//    USING THE LIBRARY
 //
+//      See the full documentation at http://sigslot.sourceforge.net/
 //
 // Libjingle specific:
+//
 // This file has been modified such that has_slots and signalx do not have to be
 // using the same threading requirements. E.g. it is possible to connect a
 // has_slots<single_threaded> and signal0<multi_threaded_local> or
@@ -87,600 +96,552 @@
 #ifndef WEBRTC_BASE_SIGSLOT_H__
 #define WEBRTC_BASE_SIGSLOT_H__
 
+#include <stdlib.h>
 #include <cstring>
 #include <list>
 #include <set>
-#include <stdlib.h>
 
 // On our copy of sigslot.h, we set single threading as default.
 #define SIGSLOT_DEFAULT_MT_POLICY single_threaded
 
-#if defined(SIGSLOT_PURE_ISO) || (!defined(WEBRTC_WIN) && !defined(__GNUG__) && !defined(SIGSLOT_USE_POSIX_THREADS))
-#	define _SIGSLOT_SINGLE_THREADED
+#if defined(SIGSLOT_PURE_ISO) ||                   \
+    (!defined(WEBRTC_WIN) && !defined(__GNUG__) && \
+     !defined(SIGSLOT_USE_POSIX_THREADS))
+#define _SIGSLOT_SINGLE_THREADED
 #elif defined(WEBRTC_WIN)
-#	define _SIGSLOT_HAS_WIN32_THREADS
-#	if !defined(WIN32_LEAN_AND_MEAN)
-#		define WIN32_LEAN_AND_MEAN
-#	endif
-#	include "webrtc/base/win32.h"
+#define _SIGSLOT_HAS_WIN32_THREADS
+#if !defined(WIN32_LEAN_AND_MEAN)
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include "webrtc/base/win32.h"
 #elif defined(__GNUG__) || defined(SIGSLOT_USE_POSIX_THREADS)
-#	define _SIGSLOT_HAS_POSIX_THREADS
-#	include <pthread.h>
+#define _SIGSLOT_HAS_POSIX_THREADS
+#include <pthread.h>
 #else
-#	define _SIGSLOT_SINGLE_THREADED
+#define _SIGSLOT_SINGLE_THREADED
 #endif
 
 #ifndef SIGSLOT_DEFAULT_MT_POLICY
-#	ifdef _SIGSLOT_SINGLE_THREADED
-#		define SIGSLOT_DEFAULT_MT_POLICY single_threaded
-#	else
-#		define SIGSLOT_DEFAULT_MT_POLICY multi_threaded_local
-#	endif
+#ifdef _SIGSLOT_SINGLE_THREADED
+#define SIGSLOT_DEFAULT_MT_POLICY single_threaded
+#else
+#define SIGSLOT_DEFAULT_MT_POLICY multi_threaded_local
+#endif
 #endif
 
 // TODO: change this namespace to rtc?
 namespace sigslot {
 
-	class single_threaded
-	{
-	public:
-		void lock() {}
-		void unlock() {}
-	};
+class single_threaded {
+ public:
+  void lock() {}
+  void unlock() {}
+};
 
 #ifdef _SIGSLOT_HAS_WIN32_THREADS
-	// The multi threading policies only get compiled in if they are enabled.
-	class multi_threaded_global
-	{
-	public:
-		multi_threaded_global()
-		{
-			static bool isinitialised = false;
-
-			if(!isinitialised)
-			{
-				InitializeCriticalSection(get_critsec());
-				isinitialised = true;
-			}
-		}
-
-		void lock()
-		{
-			EnterCriticalSection(get_critsec());
-		}
-
-		void unlock()
-		{
-			LeaveCriticalSection(get_critsec());
-		}
-
-	private:
-		CRITICAL_SECTION* get_critsec()
-		{
-			static CRITICAL_SECTION g_critsec;
-			return &g_critsec;
-		}
-	};
-
-	class multi_threaded_local
-	{
-	public:
-		multi_threaded_local()
-		{
-			InitializeCriticalSection(&m_critsec);
-		}
-
-		multi_threaded_local(const multi_threaded_local&)
-		{
-			InitializeCriticalSection(&m_critsec);
-		}
-
-		~multi_threaded_local()
-		{
-			DeleteCriticalSection(&m_critsec);
-		}
-
-		void lock()
-		{
-			EnterCriticalSection(&m_critsec);
-		}
-
-		void unlock()
-		{
-			LeaveCriticalSection(&m_critsec);
-		}
-
-	private:
-		CRITICAL_SECTION m_critsec;
-	};
-#endif // _SIGSLOT_HAS_WIN32_THREADS
+// The multi threading policies only get compiled in if they are enabled.
+class multi_threaded_global {
+ public:
+  multi_threaded_global() {
+    static bool isinitialised = false;
+
+    if (!isinitialised) {
+      InitializeCriticalSection(get_critsec());
+      isinitialised = true;
+    }
+  }
+
+  void lock() { EnterCriticalSection(get_critsec()); }
+
+  void unlock() { LeaveCriticalSection(get_critsec()); }
+
+ private:
+  CRITICAL_SECTION* get_critsec() {
+    static CRITICAL_SECTION g_critsec;
+    return &g_critsec;
+  }
+};
+
+class multi_threaded_local {
+ public:
+  multi_threaded_local() { InitializeCriticalSection(&m_critsec); }
+
+  multi_threaded_local(const multi_threaded_local&) {
+    InitializeCriticalSection(&m_critsec);
+  }
+
+  ~multi_threaded_local() { DeleteCriticalSection(&m_critsec); }
+
+  void lock() { EnterCriticalSection(&m_critsec); }
+
+  void unlock() { LeaveCriticalSection(&m_critsec); }
+
+ private:
+  CRITICAL_SECTION m_critsec;
+};
+#endif  // _SIGSLOT_HAS_WIN32_THREADS
 
 #ifdef _SIGSLOT_HAS_POSIX_THREADS
-	// The multi threading policies only get compiled in if they are enabled.
-	class multi_threaded_global
-	{
-	public:
-		void lock()
-		{
-			pthread_mutex_lock(get_mutex());
-		}
-		void unlock()
-		{
-			pthread_mutex_unlock(get_mutex());
-		}
-
-	private:
-		static pthread_mutex_t* get_mutex();
-	};
-
-	class multi_threaded_local
-	{
-	public:
-		multi_threaded_local() { pthread_mutex_init(&m_mutex, nullptr); }
-		multi_threaded_local(const multi_threaded_local&) {
-			pthread_mutex_init(&m_mutex, nullptr);
-		}
-		~multi_threaded_local()
-		{
-			pthread_mutex_destroy(&m_mutex);
-		}
-		void lock()
-		{
-			pthread_mutex_lock(&m_mutex);
-		}
-		void unlock()
-		{
-			pthread_mutex_unlock(&m_mutex);
-		}
-
-	private:
-		pthread_mutex_t m_mutex;
-	};
-#endif // _SIGSLOT_HAS_POSIX_THREADS
-
-	template<class mt_policy>
-	class lock_block
-	{
-	public:
-		mt_policy *m_mutex;
-
-		lock_block(mt_policy *mtx)
-			: m_mutex(mtx)
-		{
-			m_mutex->lock();
-		}
-
-		~lock_block()
-		{
-			m_mutex->unlock();
-		}
-	};
-
-	class _signal_base_interface;
-
-	class has_slots_interface
-	{
-	private:
-		typedef void (*signal_connect_t)(has_slots_interface* self, _signal_base_interface* sender);
-		typedef void (*signal_disconnect_t)(has_slots_interface* self, _signal_base_interface* sender);
-		typedef void (*disconnect_all_t)(has_slots_interface* self);
-
-		const signal_connect_t m_signal_connect;
-		const signal_disconnect_t m_signal_disconnect;
-		const disconnect_all_t m_disconnect_all;
-
-	protected:
-		has_slots_interface(signal_connect_t conn, signal_disconnect_t disc, disconnect_all_t disc_all) :
-			m_signal_connect(conn), m_signal_disconnect(disc), m_disconnect_all(disc_all)
-		{
-		}
-
-		// Doesn't really need to be virtual, but is for backwards compatibility
-		// (it was virtual in a previous version of sigslot).
-		virtual ~has_slots_interface() {}
-
-	public:
-		void signal_connect(_signal_base_interface* sender)
-		{
-			m_signal_connect(this, sender);
-		}
-
-		void signal_disconnect(_signal_base_interface* sender)
-		{
-			m_signal_disconnect(this, sender);
-		}
-
-		void disconnect_all()
-		{
-			m_disconnect_all(this);
-		}
-	};
-
-	class _signal_base_interface
-	{
-	private:
-		typedef void (*slot_disconnect_t)(_signal_base_interface* self, has_slots_interface* pslot);
-		typedef void (*slot_duplicate_t)(_signal_base_interface* self, const has_slots_interface* poldslot, has_slots_interface* pnewslot);
-
-		const slot_disconnect_t m_slot_disconnect;
-		const slot_duplicate_t m_slot_duplicate;
-
-	protected:
-		_signal_base_interface(slot_disconnect_t disc, slot_duplicate_t dupl) :
-			m_slot_disconnect(disc), m_slot_duplicate(dupl)
-		{
-		}
-
-		~_signal_base_interface() {}
-
-	public:
-		void slot_disconnect(has_slots_interface* pslot)
-		{
-			m_slot_disconnect(this, pslot);
-		}
-
-		void slot_duplicate(const has_slots_interface* poldslot, has_slots_interface* pnewslot)
-		{
-			m_slot_duplicate(this, poldslot, pnewslot);
-		}
-	};
-
-	class _opaque_connection
-	{
-	private:
-		typedef void (*emit_t)(const _opaque_connection*);
-		template< typename FromT, typename ToT >
-		union union_caster
-		{
-			FromT from;
-			ToT to;
-		};
-
-		emit_t pemit;
-		has_slots_interface* pdest;
-		// Pointers to member functions may be up to 16 bytes for virtual classes,
-		// so make sure we have enough space to store it.
-		unsigned char pmethod[16];
-
-	public:
-		template< typename DestT, typename ... Args >
-		_opaque_connection(DestT* pd, void (DestT::*pm)(Args...)) : pdest(pd)
-		{
-			typedef void (DestT::*pm_t)(Args...);
-			static_assert(sizeof(pm_t) <= sizeof(pmethod), "Size of slot function pointer too large.");
-
-			std::memcpy(pmethod, &pm, sizeof(pm_t));
-
-			typedef void (*em_t)(const _opaque_connection* self, Args...);
-			union_caster< em_t, emit_t > caster2;
-			caster2.from = &_opaque_connection::emitter< DestT, Args... >;
-			pemit = caster2.to;
-		}
-
-		has_slots_interface* getdest() const { return pdest; }
-
-		_opaque_connection duplicate(has_slots_interface* newtarget) const
-		{
-			_opaque_connection res = *this;
-			res.pdest = newtarget;
-			return res;
-		}
-
-		// Just calls the stored "emitter" function pointer stored at construction
-		// time.
-		template< typename ... Args >
-		void emit(Args... args) const
-		{
-			typedef void (*em_t)(const _opaque_connection*, Args...);
-			union_caster< emit_t, em_t > caster;
-			caster.from = pemit;
-			(caster.to)(this, args...);
-		}
-
-	private:
-		template< typename DestT, typename ... Args >
-		static void emitter(const _opaque_connection* self, Args... args)
-		{
-			typedef void (DestT::*pm_t)(Args...);
-			pm_t pm;
-			std::memcpy(&pm, self->pmethod, sizeof(pm_t));
-			(static_cast< DestT* >(self->pdest)->*(pm))(args...);
-		}
-	};
-
-	template<class mt_policy>
-	class _signal_base : public _signal_base_interface, public mt_policy
-	{
-	protected:
-		typedef std::list< _opaque_connection > connections_list;
-
-		_signal_base() : _signal_base_interface(&_signal_base::do_slot_disconnect, &_signal_base::do_slot_duplicate),
-    m_current_iterator(m_connected_slots.end())
-		{
-		}
-
-		~_signal_base()
-		{
-			disconnect_all();
-		}
-
-	private:
-		_signal_base& operator= (_signal_base const& that);
-
-	public:
-		_signal_base(const _signal_base& o) : _signal_base_interface(&_signal_base::do_slot_disconnect, &_signal_base::do_slot_duplicate),
-   m_current_iterator(m_connected_slots.end()) {
-			lock_block<mt_policy> lock(this);
-      for (const auto& connection : o.m_connected_slots)
-			{
-				connection.getdest()->signal_connect(this);
-				m_connected_slots.push_back(connection);
-			}
-		}
-
-		bool is_empty()
-		{
-			lock_block<mt_policy> lock(this);
-			return m_connected_slots.empty();
-		}
-
-		void disconnect_all()
-		{
-			lock_block<mt_policy> lock(this);
-
-			while(!m_connected_slots.empty())
-			{
-				has_slots_interface* pdest = m_connected_slots.front().getdest();
-				m_connected_slots.pop_front();
-				pdest->signal_disconnect(static_cast< _signal_base_interface* >(this));
-			}
-      // If disconnect_all is called while the signal is firing, advance the
-      // current slot iterator to the end to avoid an invalidated iterator from
-      // being dereferenced.
-      m_current_iterator = m_connected_slots.end();
-		}
+// The multi threading policies only get compiled in if they are enabled.
+class multi_threaded_global {
+ public:
+  void lock() { pthread_mutex_lock(get_mutex()); }
+  void unlock() { pthread_mutex_unlock(get_mutex()); }
+
+ private:
+  static pthread_mutex_t* get_mutex();
+};
+
+class multi_threaded_local {
+ public:
+  multi_threaded_local() { pthread_mutex_init(&m_mutex, nullptr); }
+  multi_threaded_local(const multi_threaded_local&) {
+    pthread_mutex_init(&m_mutex, nullptr);
+  }
+  ~multi_threaded_local() { pthread_mutex_destroy(&m_mutex); }
+  void lock() { pthread_mutex_lock(&m_mutex); }
+  void unlock() { pthread_mutex_unlock(&m_mutex); }
+
+ private:
+  pthread_mutex_t m_mutex;
+};
+#endif  // _SIGSLOT_HAS_POSIX_THREADS
+
+template <class mt_policy>
+class lock_block {
+ public:
+  mt_policy* m_mutex;
+
+  lock_block(mt_policy* mtx) : m_mutex(mtx) { m_mutex->lock(); }
+
+  ~lock_block() { m_mutex->unlock(); }
+};
+
+class _signal_base_interface;
+
+class has_slots_interface {
+ private:
+  typedef void (*signal_connect_t)(has_slots_interface* self,
+                                   _signal_base_interface* sender);
+  typedef void (*signal_disconnect_t)(has_slots_interface* self,
+                                      _signal_base_interface* sender);
+  typedef void (*disconnect_all_t)(has_slots_interface* self);
+
+  const signal_connect_t m_signal_connect;
+  const signal_disconnect_t m_signal_disconnect;
+  const disconnect_all_t m_disconnect_all;
+
+ protected:
+  has_slots_interface(signal_connect_t conn,
+                      signal_disconnect_t disc,
+                      disconnect_all_t disc_all)
+      : m_signal_connect(conn),
+        m_signal_disconnect(disc),
+        m_disconnect_all(disc_all) {}
+
+  // Doesn't really need to be virtual, but is for backwards compatibility
+  // (it was virtual in a previous version of sigslot).
+  virtual ~has_slots_interface() {}
+
+ public:
+  void signal_connect(_signal_base_interface* sender) {
+    m_signal_connect(this, sender);
+  }
+
+  void signal_disconnect(_signal_base_interface* sender) {
+    m_signal_disconnect(this, sender);
+  }
+
+  void disconnect_all() { m_disconnect_all(this); }
+};
+
+class _signal_base_interface {
+ private:
+  typedef void (*slot_disconnect_t)(_signal_base_interface* self,
+                                    has_slots_interface* pslot);
+  typedef void (*slot_duplicate_t)(_signal_base_interface* self,
+                                   const has_slots_interface* poldslot,
+                                   has_slots_interface* pnewslot);
+
+  const slot_disconnect_t m_slot_disconnect;
+  const slot_duplicate_t m_slot_duplicate;
+
+ protected:
+  _signal_base_interface(slot_disconnect_t disc, slot_duplicate_t dupl)
+      : m_slot_disconnect(disc), m_slot_duplicate(dupl) {}
+
+  ~_signal_base_interface() {}
+
+ public:
+  void slot_disconnect(has_slots_interface* pslot) {
+    m_slot_disconnect(this, pslot);
+  }
+
+  void slot_duplicate(const has_slots_interface* poldslot,
+                      has_slots_interface* pnewslot) {
+    m_slot_duplicate(this, poldslot, pnewslot);
+  }
+};
+
+class _opaque_connection {
+ private:
+  typedef void (*emit_t)(const _opaque_connection*);
+  template <typename FromT, typename ToT>
+  union union_caster {
+    FromT from;
+    ToT to;
+  };
+
+  emit_t pemit;
+  has_slots_interface* pdest;
+  // Pointers to member functions may be up to 16 bytes for virtual classes,
+  // so make sure we have enough space to store it.
+  unsigned char pmethod[16];
+
+ public:
+  template <typename DestT, typename... Args>
+  _opaque_connection(DestT* pd, void (DestT::*pm)(Args...)) : pdest(pd) {
+    typedef void (DestT::*pm_t)(Args...);
+    static_assert(sizeof(pm_t) <= sizeof(pmethod),
+                  "Size of slot function pointer too large.");
+
+    std::memcpy(pmethod, &pm, sizeof(pm_t));
+
+    typedef void (*em_t)(const _opaque_connection* self, Args...);
+    union_caster<em_t, emit_t> caster2;
+    caster2.from = &_opaque_connection::emitter<DestT, Args...>;
+    pemit = caster2.to;
+  }
+
+  has_slots_interface* getdest() const { return pdest; }
+
+  _opaque_connection duplicate(has_slots_interface* newtarget) const {
+    _opaque_connection res = *this;
+    res.pdest = newtarget;
+    return res;
+  }
+
+  // Just calls the stored "emitter" function pointer stored at construction
+  // time.
+  template <typename... Args>
+  void emit(Args... args) const {
+    typedef void (*em_t)(const _opaque_connection*, Args...);
+    union_caster<emit_t, em_t> caster;
+    caster.from = pemit;
+    (caster.to)(this, args...);
+  }
+
+ private:
+  template <typename DestT, typename... Args>
+  static void emitter(const _opaque_connection* self, Args... args) {
+    typedef void (DestT::*pm_t)(Args...);
+    pm_t pm;
+    std::memcpy(&pm, self->pmethod, sizeof(pm_t));
+    (static_cast<DestT*>(self->pdest)->*(pm))(args...);
+  }
+};
+
+template <class mt_policy>
+class _signal_base : public _signal_base_interface, public mt_policy {
+ protected:
+  typedef std::list<_opaque_connection> connections_list;
+
+  _signal_base()
+      : _signal_base_interface(&_signal_base::do_slot_disconnect,
+                               &_signal_base::do_slot_duplicate),
+        m_current_iterator(m_connected_slots.end()) {}
+
+  ~_signal_base() { disconnect_all(); }
+
+ private:
+  _signal_base& operator=(_signal_base const& that);
+
+ public:
+  _signal_base(const _signal_base& o)
+      : _signal_base_interface(&_signal_base::do_slot_disconnect,
+                               &_signal_base::do_slot_duplicate),
+        m_current_iterator(m_connected_slots.end()) {
+    lock_block<mt_policy> lock(this);
+    for (const auto& connection : o.m_connected_slots) {
+      connection.getdest()->signal_connect(this);
+      m_connected_slots.push_back(connection);
+    }
+  }
+
+  bool is_empty() {
+    lock_block<mt_policy> lock(this);
+    return m_connected_slots.empty();
+  }
+
+  void disconnect_all() {
+    lock_block<mt_policy> lock(this);
+
+    while (!m_connected_slots.empty()) {
+      has_slots_interface* pdest = m_connected_slots.front().getdest();
+      m_connected_slots.pop_front();
+      pdest->signal_disconnect(static_cast<_signal_base_interface*>(this));
+    }
+    // If disconnect_all is called while the signal is firing, advance the
+    // current slot iterator to the end to avoid an invalidated iterator from
+    // being dereferenced.
+    m_current_iterator = m_connected_slots.end();
+  }
 
 #if !defined(NDEBUG)
-		bool connected(has_slots_interface* pclass)
-		{
-			lock_block<mt_policy> lock(this);
-			connections_list::const_iterator it = m_connected_slots.begin();
-			connections_list::const_iterator itEnd = m_connected_slots.end();
-			while(it != itEnd)
-			{
-				if (it->getdest() == pclass)
-					return true;
-				++it;
-			}
-			return false;
-		}
+  bool connected(has_slots_interface* pclass) {
+    lock_block<mt_policy> lock(this);
+    connections_list::const_iterator it = m_connected_slots.begin();
+    connections_list::const_iterator itEnd = m_connected_slots.end();
+    while (it != itEnd) {
+      if (it->getdest() == pclass)
+        return true;
+      ++it;
+    }
+    return false;
+  }
 #endif
 
-		void disconnect(has_slots_interface* pclass)
-		{
-			lock_block<mt_policy> lock(this);
-			connections_list::iterator it = m_connected_slots.begin();
-			connections_list::iterator itEnd = m_connected_slots.end();
-
-			while(it != itEnd)
-			{
-				if(it->getdest() == pclass)
-				{
-          // If we're currently using this iterator because the signal is
-          // firing, advance it to avoid it being invalidated.
-          if (m_current_iterator == it) {
-            m_current_iterator = m_connected_slots.erase(it);
-          } else {
-            m_connected_slots.erase(it);
-          }
-					pclass->signal_disconnect(static_cast< _signal_base_interface* >(this));
-					return;
-				}
-
-				++it;
-			}
-		}
-
-	private:
-		static void do_slot_disconnect(_signal_base_interface* p, has_slots_interface* pslot)
-		{
-			_signal_base* const self = static_cast< _signal_base* >(p);
-			lock_block<mt_policy> lock(self);
-			connections_list::iterator it = self->m_connected_slots.begin();
-			connections_list::iterator itEnd = self->m_connected_slots.end();
-
-			while(it != itEnd)
-			{
-				connections_list::iterator itNext = it;
-				++itNext;
-
-				if(it->getdest() == pslot)
-				{
-          // If we're currently using this iterator because the signal is
-          // firing, advance it to avoid it being invalidated.
-          if (self->m_current_iterator == it) {
-            self->m_current_iterator = self->m_connected_slots.erase(it);
-          } else {
-            self->m_connected_slots.erase(it);
-          }
+  void disconnect(has_slots_interface* pclass) {
+    lock_block<mt_policy> lock(this);
+    connections_list::iterator it = m_connected_slots.begin();
+    connections_list::iterator itEnd = m_connected_slots.end();
+
+    while (it != itEnd) {
+      if (it->getdest() == pclass) {
+        // If we're currently using this iterator because the signal is firing,
+        // advance it to avoid it being invalidated.
+        if (m_current_iterator == it) {
+          m_current_iterator = m_connected_slots.erase(it);
+        } else {
+          m_connected_slots.erase(it);
         }
-
-				it = itNext;
-			}
-		}
-
-		static void do_slot_duplicate(_signal_base_interface* p, const has_slots_interface* oldtarget, has_slots_interface* newtarget)
-		{
-			_signal_base* const self = static_cast< _signal_base* >(p);
-			lock_block<mt_policy> lock(self);
-			connections_list::iterator it = self->m_connected_slots.begin();
-			connections_list::iterator itEnd = self->m_connected_slots.end();
-
-			while(it != itEnd)
-			{
-				if(it->getdest() == oldtarget)
-				{
-					self->m_connected_slots.push_back(it->duplicate(newtarget));
-				}
-
-				++it;
-			}
-		}
-
-	protected:
-		connections_list m_connected_slots;
-
-                // Used to handle a slot being disconnected while a signal is
-                // firing (iterating m_connected_slots).
-                connections_list::iterator m_current_iterator;
-        };
-
-	template<class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-	class has_slots : public has_slots_interface, public mt_policy
-	{
-	private:
-		typedef std::set< _signal_base_interface* > sender_set;
-		typedef sender_set::const_iterator const_iterator;
-
-	public:
-		has_slots() : has_slots_interface(&has_slots::do_signal_connect, &has_slots::do_signal_disconnect, &has_slots::do_disconnect_all)
-		{
-		}
-
-		has_slots(has_slots const& o) : has_slots_interface(&has_slots::do_signal_connect, &has_slots::do_signal_disconnect, &has_slots::do_disconnect_all)
-    {
-			lock_block<mt_policy> lock(this);
-      for (auto* sender : o.m_senders) {
-        sender->slot_duplicate(&o, this);
-        m_senders.insert(sender);
+        pclass->signal_disconnect(static_cast<_signal_base_interface*>(this));
+        return;
       }
+      ++it;
     }
+  }
+
+ private:
+  static void do_slot_disconnect(_signal_base_interface* p,
+                                 has_slots_interface* pslot) {
+    _signal_base* const self = static_cast<_signal_base*>(p);
+    lock_block<mt_policy> lock(self);
+    connections_list::iterator it = self->m_connected_slots.begin();
+    connections_list::iterator itEnd = self->m_connected_slots.end();
+
+    while (it != itEnd) {
+      connections_list::iterator itNext = it;
+      ++itNext;
+
+      if (it->getdest() == pslot) {
+        // If we're currently using this iterator because the signal is firing,
+        // advance it to avoid it being invalidated.
+        if (self->m_current_iterator == it) {
+          self->m_current_iterator = self->m_connected_slots.erase(it);
+        } else {
+          self->m_connected_slots.erase(it);
+        }
+      }
 
-		~has_slots()
-		{
-			this->disconnect_all();
-		}
-
-	private:
-		has_slots& operator= (has_slots const&);
-
-		static void do_signal_connect(has_slots_interface* p, _signal_base_interface* sender)
-		{
-			has_slots* const self = static_cast< has_slots* >(p);
-			lock_block<mt_policy> lock(self);
-			self->m_senders.insert(sender);
-		}
-
-		static void do_signal_disconnect(has_slots_interface* p, _signal_base_interface* sender)
-		{
-			has_slots* const self = static_cast< has_slots* >(p);
-			lock_block<mt_policy> lock(self);
-			self->m_senders.erase(sender);
-		}
-
-		static void do_disconnect_all(has_slots_interface* p)
-		{
-			has_slots* const self = static_cast< has_slots* >(p);
-			lock_block<mt_policy> lock(self);
-			while (!self->m_senders.empty())
-			{
-				std::set< _signal_base_interface* > senders;
-				senders.swap(self->m_senders);
-				const_iterator it = senders.begin();
-				const_iterator itEnd = senders.end();
-
-				while(it != itEnd)
-				{
-					_signal_base_interface* s = *it;
-					++it;
-					s->slot_disconnect(p);
-				}
-			}
-		}
-
-	private:
-		sender_set m_senders;
-	};
-
-	template<class mt_policy, typename ... Args>
-	class signal_with_thread_policy : public _signal_base<mt_policy>
-	{
-	private:
-		typedef _signal_base<mt_policy> base;
-
-	protected:
-		typedef typename base::connections_list connections_list;
-
-	public:
-		signal_with_thread_policy()
-		{
-		}
-
-		template<class desttype>
-		void connect(desttype* pclass, void (desttype::*pmemfun)(Args...))
-		{
-			lock_block<mt_policy> lock(this);
-			this->m_connected_slots.push_back(_opaque_connection(pclass, pmemfun));
-			pclass->signal_connect(static_cast< _signal_base_interface* >(this));
-		}
-
-		void emit(Args... args)
-		{
-			lock_block<mt_policy> lock(this);
-                        this->m_current_iterator =
-                            this->m_connected_slots.begin();
-                        while (this->m_current_iterator !=
-                               this->m_connected_slots.end()) {
-                          _opaque_connection const& conn =
-                              *this->m_current_iterator;
-                          ++(this->m_current_iterator);
-                          conn.emit<Args...>(args...);
-                        }
-		}
-
-		void operator()(Args... args)
-		{
-			emit(args...);
-		}
-	};
-
-	// Alias with default thread policy. Needed because both default arguments
-	// and variadic template arguments must go at the end of the list, so we
-	// can't have both at once.
-	template<typename ... Args>
-	using signal = signal_with_thread_policy<SIGSLOT_DEFAULT_MT_POLICY, Args...>;
-
-	// The previous verion of sigslot didn't use variadic templates, so you would
-	// need to write "sigslot::signal2<Arg1, Arg2>", for example.
-	// Now you can just write "sigslot::signal<Arg1, Arg2>", but these aliases
-	// exist for backwards compatibility.
-	template<typename mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-	using signal0 = signal_with_thread_policy<mt_policy>;
-
-	template<typename A1, typename mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-	using signal1 = signal_with_thread_policy<mt_policy, A1>;
-
-	template<typename A1, typename A2, typename mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-	using signal2 = signal_with_thread_policy<mt_policy, A1, A2>;
-
-	template<typename A1, typename A2, typename A3, typename mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-	using signal3 = signal_with_thread_policy<mt_policy, A1, A2, A3>;
-
-	template<typename A1, typename A2, typename A3, typename A4, typename mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-	using signal4 = signal_with_thread_policy<mt_policy, A1, A2, A3, A4>;
-
-	template<typename A1, typename A2, typename A3, typename A4, typename A5, typename mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-	using signal5 = signal_with_thread_policy<mt_policy, A1, A2, A3, A4, A5>;
-
-	template<typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-	using signal6 = signal_with_thread_policy<mt_policy, A1, A2, A3, A4, A5, A6>;
-
-	template<typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-	using signal7 = signal_with_thread_policy<mt_policy, A1, A2, A3, A4, A5, A6, A7>;
-
-	template<typename A1, typename A2, typename A3, typename A4, typename A5, typename A6, typename A7, typename A8, typename mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
-	using signal8 = signal_with_thread_policy<mt_policy, A1, A2, A3, A4, A5, A6, A7, A8>;
-
-} // namespace sigslot
-
-#endif // WEBRTC_BASE_SIGSLOT_H__
+      it = itNext;
+    }
+  }
+
+  static void do_slot_duplicate(_signal_base_interface* p,
+                                const has_slots_interface* oldtarget,
+                                has_slots_interface* newtarget) {
+    _signal_base* const self = static_cast<_signal_base*>(p);
+    lock_block<mt_policy> lock(self);
+    connections_list::iterator it = self->m_connected_slots.begin();
+    connections_list::iterator itEnd = self->m_connected_slots.end();
+
+    while (it != itEnd) {
+      if (it->getdest() == oldtarget) {
+        self->m_connected_slots.push_back(it->duplicate(newtarget));
+      }
+
+      ++it;
+    }
+  }
+
+ protected:
+  connections_list m_connected_slots;
+
+  // Used to handle a slot being disconnected while a signal is
+  // firing (iterating m_connected_slots).
+  connections_list::iterator m_current_iterator;
+  bool m_erase_current_iterator = false;
+};
+
+template <class mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+class has_slots : public has_slots_interface, public mt_policy {
+ private:
+  typedef std::set<_signal_base_interface*> sender_set;
+  typedef sender_set::const_iterator const_iterator;
+
+ public:
+  has_slots()
+      : has_slots_interface(&has_slots::do_signal_connect,
+                            &has_slots::do_signal_disconnect,
+                            &has_slots::do_disconnect_all) {}
+
+  has_slots(has_slots const& o)
+      : has_slots_interface(&has_slots::do_signal_connect,
+                            &has_slots::do_signal_disconnect,
+                            &has_slots::do_disconnect_all) {
+    lock_block<mt_policy> lock(this);
+    for (auto* sender : o.m_senders) {
+      sender->slot_duplicate(&o, this);
+      m_senders.insert(sender);
+    }
+  }
+
+  ~has_slots() { this->disconnect_all(); }
+
+ private:
+  has_slots& operator=(has_slots const&);
+
+  static void do_signal_connect(has_slots_interface* p,
+                                _signal_base_interface* sender) {
+    has_slots* const self = static_cast<has_slots*>(p);
+    lock_block<mt_policy> lock(self);
+    self->m_senders.insert(sender);
+  }
+
+  static void do_signal_disconnect(has_slots_interface* p,
+                                   _signal_base_interface* sender) {
+    has_slots* const self = static_cast<has_slots*>(p);
+    lock_block<mt_policy> lock(self);
+    self->m_senders.erase(sender);
+  }
+
+  static void do_disconnect_all(has_slots_interface* p) {
+    has_slots* const self = static_cast<has_slots*>(p);
+    lock_block<mt_policy> lock(self);
+    while (!self->m_senders.empty()) {
+      std::set<_signal_base_interface*> senders;
+      senders.swap(self->m_senders);
+      const_iterator it = senders.begin();
+      const_iterator itEnd = senders.end();
+
+      while (it != itEnd) {
+        _signal_base_interface* s = *it;
+        ++it;
+        s->slot_disconnect(p);
+      }
+    }
+  }
+
+ private:
+  sender_set m_senders;
+};
+
+template <class mt_policy, typename... Args>
+class signal_with_thread_policy : public _signal_base<mt_policy> {
+ private:
+  typedef _signal_base<mt_policy> base;
+
+ protected:
+  typedef typename base::connections_list connections_list;
+
+ public:
+  signal_with_thread_policy() {}
+
+  template <class desttype>
+  void connect(desttype* pclass, void (desttype::*pmemfun)(Args...)) {
+    lock_block<mt_policy> lock(this);
+    this->m_connected_slots.push_back(_opaque_connection(pclass, pmemfun));
+    pclass->signal_connect(static_cast<_signal_base_interface*>(this));
+  }
+
+  void emit(Args... args) {
+    lock_block<mt_policy> lock(this);
+    this->m_current_iterator = this->m_connected_slots.begin();
+    while (this->m_current_iterator != this->m_connected_slots.end()) {
+      _opaque_connection const& conn = *this->m_current_iterator;
+      ++(this->m_current_iterator);
+      conn.emit<Args...>(args...);
+    }
+  }
+
+  void operator()(Args... args) { emit(args...); }
+};
+
+// Alias with default thread policy. Needed because both default arguments
+// and variadic template arguments must go at the end of the list, so we
+// can't have both at once.
+template <typename... Args>
+using signal = signal_with_thread_policy<SIGSLOT_DEFAULT_MT_POLICY, Args...>;
+
+// The previous verion of sigslot didn't use variadic templates, so you would
+// need to write "sigslot::signal2<Arg1, Arg2>", for example.
+// Now you can just write "sigslot::signal<Arg1, Arg2>", but these aliases
+// exist for backwards compatibility.
+template <typename mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+using signal0 = signal_with_thread_policy<mt_policy>;
+
+template <typename A1, typename mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+using signal1 = signal_with_thread_policy<mt_policy, A1>;
+
+template <typename A1,
+          typename A2,
+          typename mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+using signal2 = signal_with_thread_policy<mt_policy, A1, A2>;
+
+template <typename A1,
+          typename A2,
+          typename A3,
+          typename mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+using signal3 = signal_with_thread_policy<mt_policy, A1, A2, A3>;
+
+template <typename A1,
+          typename A2,
+          typename A3,
+          typename A4,
+          typename mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+using signal4 = signal_with_thread_policy<mt_policy, A1, A2, A3, A4>;
+
+template <typename A1,
+          typename A2,
+          typename A3,
+          typename A4,
+          typename A5,
+          typename mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+using signal5 = signal_with_thread_policy<mt_policy, A1, A2, A3, A4, A5>;
+
+template <typename A1,
+          typename A2,
+          typename A3,
+          typename A4,
+          typename A5,
+          typename A6,
+          typename mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+using signal6 = signal_with_thread_policy<mt_policy, A1, A2, A3, A4, A5, A6>;
+
+template <typename A1,
+          typename A2,
+          typename A3,
+          typename A4,
+          typename A5,
+          typename A6,
+          typename A7,
+          typename mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+using signal7 =
+    signal_with_thread_policy<mt_policy, A1, A2, A3, A4, A5, A6, A7>;
+
+template <typename A1,
+          typename A2,
+          typename A3,
+          typename A4,
+          typename A5,
+          typename A6,
+          typename A7,
+          typename A8,
+          typename mt_policy = SIGSLOT_DEFAULT_MT_POLICY>
+using signal8 =
+    signal_with_thread_policy<mt_policy, A1, A2, A3, A4, A5, A6, A7, A8>;
+
+}  // namespace sigslot
+
+#endif  // WEBRTC_BASE_SIGSLOT_H__