Relanding #2: Fixing crash that can occur if signal is modified while firing.

webrtc/base/sigslot.h

 // sigslot.h: Signal/Slot classes
 //
 // 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.
 //
 // QUICK DOCUMENTATION
 //
 //                              (see also the full documentation at http://sigslot.sourceforge.net/)
@@ skipping 376 matching lines @@
                         (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)
+                _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) {
+                _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;
                 }
 #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)
                                 {
-                                        m_connected_slots.erase(it);
+          // 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)
                                 {
-                                        self->m_connected_slots.erase(it);
-                                }
+          // 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);
+          }
+        }
 
                                 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)
@@ skipping 73 matching lines @@
                 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);
-                        typename connections_list::const_iterator it = this->m_connected_slots.begin();
-                        typename connections_list::const_iterator itEnd = this->m_connected_slots.end();
-
-                        while(it != itEnd)
-                        {
-                                _opaque_connection const& conn = *it;
-                                ++it;
-
-                                conn.emit<Args...>(args...);
-                        }
+                        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
@@ skipping 28 matching lines @@
 
         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__