Revert of 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),
-    m_current_iterator(m_connected_slots.end())
+                _signal_base() : _signal_base_interface(&_signal_base::do_slot_disconnect, &_signal_base::do_slot_duplicate)
                 {
                 }
 
                 ~_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()) {
+                _signal_base(const _signal_base& o) : _signal_base_interface(&_signal_base::do_slot_disconnect, &_signal_base::do_slot_duplicate) {
                         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()
                 {
@@ skipping 32 matching lines @@
                 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,
-          // don't erase it and invalidate it yet; set a
-          // flag to do so afterwards.
-          if (m_current_iterator == it) {
-            m_erase_current_iterator = true;
-          } else {
-            m_connected_slots.erase(it);
-          }
+                                        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,
-                                  // don't erase it and invalidate it yet; set a
-                                  // flag to do so afterwards.
-                                  if (self->m_current_iterator == it) {
-                                    self->m_erase_current_iterator = true;
-                                  } else {
-                                    self->m_connected_slots.erase(it);
-                                  }
-                                }
+                                        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;
-                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)
@@ 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);
-                        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;
-                          conn.emit<Args...>(args...);
-                          if (this->m_erase_current_iterator) {
-                            this->m_current_iterator =
-                                this->m_connected_slots.erase(
-                                    this->m_current_iterator);
-                            this->m_erase_current_iterator = false;
-                          } else {
-                            ++(this->m_current_iterator);
-                          }
-                        }
+                        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...);
+                        }
                 }
 
                 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__