1 files changed, 109 insertions, 59 deletions

diff --git a/lldb/source/Core/Broadcaster.cpp b/lldb/source/Core/Broadcaster.cpp
index 84a42ae3d7e..6494e3d85bc 100644
--- a/lldb/source/Core/Broadcaster.cpp
+++ b/lldb/source/Core/Broadcaster.cpp
@@ -15,23 +15,31 @@
 // Project includes
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Event.h"
+#include "lldb/Core/Listener.h"
 #include "lldb/Core/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-Broadcaster::Broadcaster (BroadcasterManager *manager, const char *name) :
-    m_broadcaster_name (name),
+Broadcaster::Broadcaster(BroadcasterManagerSP manager_sp, const char *name) :
+    m_broadcaster_sp(new BroadcasterImpl(*this)),
+    m_manager_sp(manager_sp),
+    m_broadcaster_name(name)
+
+{
+}
+
+Broadcaster::BroadcasterImpl::BroadcasterImpl (Broadcaster &broadcaster) :
+    m_broadcaster(broadcaster),
     m_listeners (),
     m_listeners_mutex (Mutex::eMutexTypeRecursive),
     m_hijacking_listeners(),
-    m_hijacking_masks(),
-    m_manager (manager)
+    m_hijacking_masks()
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
     if (log)
         log->Printf ("%p Broadcaster::Broadcaster(\"%s\")",
-                     static_cast<void*>(this), m_broadcaster_name.AsCString());
+                     static_cast<void*>(this), m_broadcaster.GetBroadcasterName().AsCString());
 }
 
 Broadcaster::~Broadcaster()
@@ -47,14 +55,14 @@ Broadcaster::~Broadcaster()
 void
 Broadcaster::CheckInWithManager ()
 {
-    if (m_manager != nullptr)
+    if (m_manager_sp)
     {
-        m_manager->SignUpListenersForBroadcaster(*this);
+        m_manager_sp->SignUpListenersForBroadcaster(*this);
     }
 }
 
 void
-Broadcaster::Clear()
+Broadcaster::BroadcasterImpl::Clear()
 {
     Mutex::Locker listeners_locker(m_listeners_mutex);
     
@@ -64,19 +72,19 @@ Broadcaster::Clear()
     
     collection::iterator pos, end = m_listeners.end();
     for (pos = m_listeners.begin(); pos != end; ++pos)
-        pos->first->BroadcasterWillDestruct (this);
+        pos->first->BroadcasterWillDestruct (&m_broadcaster);
     
     m_listeners.clear();
 }
 
-const ConstString &
-Broadcaster::GetBroadcasterName ()
+Broadcaster *
+Broadcaster::BroadcasterImpl::GetBroadcaster()
 {
-    return m_broadcaster_name;
+    return &m_broadcaster;
 }
 
 bool
-Broadcaster::GetEventNames (Stream &s, uint32_t event_mask, bool prefix_with_broadcaster_name) const
+Broadcaster::BroadcasterImpl::GetEventNames (Stream &s, uint32_t event_mask, bool prefix_with_broadcaster_name) const
 {
     uint32_t num_names_added = 0;
     if (event_mask && !m_event_names.empty())
@@ -94,7 +102,7 @@ Broadcaster::GetEventNames (Stream &s, uint32_t event_mask, bool prefix_with_bro
 
                     if (prefix_with_broadcaster_name)
                     {
-                        s.PutCString (m_broadcaster_name.GetCString());
+                        s.PutCString (GetBroadcasterName());
                         s.PutChar('.');
                     }
                     s.PutCString(pos->second.c_str());
@@ -107,14 +115,14 @@ Broadcaster::GetEventNames (Stream &s, uint32_t event_mask, bool prefix_with_bro
 }
 
 void
-Broadcaster::AddInitialEventsToListener (Listener *listener, uint32_t requested_events)
+Broadcaster::AddInitialEventsToListener (lldb::ListenerSP listener_sp, uint32_t requested_events)
 {
 }
 
 uint32_t
-Broadcaster::AddListener (Listener* listener, uint32_t event_mask)
+Broadcaster::BroadcasterImpl::AddListener (lldb::ListenerSP listener_sp, uint32_t event_mask)
 {
-    if (listener == nullptr)
+    if (!listener_sp)
         return 0;
 
     Mutex::Locker locker(m_listeners_mutex);
@@ -125,7 +133,7 @@ Broadcaster::AddListener (Listener* listener, uint32_t event_mask)
     uint32_t taken_event_types = 0;
     for (pos = m_listeners.begin(); pos != end; ++pos)
     {
-        if (pos->first == listener)
+        if (pos->first == listener_sp)
             existing_pos = pos;
     // For now don't descriminate on who gets what
     // FIXME: Implement "unique listener for this bit" mask
@@ -142,7 +150,7 @@ Broadcaster::AddListener (Listener* listener, uint32_t event_mask)
         if (existing_pos == end)
         {
             // Grant a new listener the available event bits
-            m_listeners.push_back(std::make_pair(listener, available_event_types));
+            m_listeners.push_back(std::make_pair(listener_sp, available_event_types));
         }
         else
         {
@@ -153,7 +161,7 @@ Broadcaster::AddListener (Listener* listener, uint32_t event_mask)
         // Individual broadcasters decide whether they have outstanding data when a
         // listener attaches, and insert it into the listener with this method.
 
-        AddInitialEventsToListener (listener, available_event_types);
+        m_broadcaster.AddInitialEventsToListener (listener_sp, available_event_types);
     }
 
     // Return the event bits that were granted to the listener
@@ -161,7 +169,7 @@ Broadcaster::AddListener (Listener* listener, uint32_t event_mask)
 }
 
 bool
-Broadcaster::EventTypeHasListeners (uint32_t event_type)
+Broadcaster::BroadcasterImpl::EventTypeHasListeners (uint32_t event_type)
 {
     Mutex::Locker locker (m_listeners_mutex);
     
@@ -181,14 +189,14 @@ Broadcaster::EventTypeHasListeners (uint32_t event_type)
 }
 
 bool
-Broadcaster::RemoveListener (Listener* listener, uint32_t event_mask)
+Broadcaster::BroadcasterImpl::RemoveListener (lldb::ListenerSP listener_sp, uint32_t event_mask)
 {
     Mutex::Locker locker(m_listeners_mutex);
     collection::iterator pos, end = m_listeners.end();
     // See if we already have this listener, and if so, update its mask
     for (pos = m_listeners.begin(); pos != end; ++pos)
     {
-        if (pos->first == listener)
+        if (pos->first == listener_sp)
         {
             // Relinquish all event bits in "event_mask"
             pos->second &= ~event_mask;
@@ -202,38 +210,39 @@ Broadcaster::RemoveListener (Listener* listener, uint32_t event_mask)
 }
 
 void
-Broadcaster::BroadcastEvent (EventSP &event_sp)
+Broadcaster::BroadcasterImpl::BroadcastEvent (EventSP &event_sp)
 {
     return PrivateBroadcastEvent (event_sp, false);
 }
 
 void
-Broadcaster::BroadcastEventIfUnique (EventSP &event_sp)
+Broadcaster::BroadcasterImpl::BroadcastEventIfUnique (EventSP &event_sp)
 {
     return PrivateBroadcastEvent (event_sp, true);
 }
 
 void
-Broadcaster::PrivateBroadcastEvent (EventSP &event_sp, bool unique)
+Broadcaster::BroadcasterImpl::PrivateBroadcastEvent (EventSP &event_sp, bool unique)
 {
     // Can't add a nullptr event...
     if (!event_sp)
         return;
 
     // Update the broadcaster on this event
-    event_sp->SetBroadcaster (this);
+    event_sp->SetBroadcaster (&m_broadcaster);
 
     const uint32_t event_type = event_sp->GetType();
 
     Mutex::Locker event_types_locker(m_listeners_mutex);
 
-    Listener *hijacking_listener = nullptr;
+    ListenerSP hijacking_listener_sp;
+
     if (!m_hijacking_listeners.empty())
     {
         assert (!m_hijacking_masks.empty());
-        hijacking_listener = m_hijacking_listeners.back();
+        hijacking_listener_sp = m_hijacking_listeners.back();
         if ((event_type & m_hijacking_masks.back()) == 0)
-            hijacking_listener = nullptr;
+            hijacking_listener_sp.reset();
     }
 
     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS));
@@ -242,16 +251,16 @@ Broadcaster::PrivateBroadcastEvent (EventSP &event_sp, bool unique)
         StreamString event_description;
         event_sp->Dump  (&event_description);
         log->Printf ("%p Broadcaster(\"%s\")::BroadcastEvent (event_sp = {%s}, unique =%i) hijack = %p",
-                     static_cast<void*>(this), m_broadcaster_name.AsCString(""),
+                     static_cast<void*>(this), GetBroadcasterName(),
                      event_description.GetData(), unique,
-                     static_cast<void*>(hijacking_listener));
+                     static_cast<void*>(hijacking_listener_sp.get()));
     }
 
-    if (hijacking_listener)
+    if (hijacking_listener_sp)
     {
-        if (unique && hijacking_listener->PeekAtNextEventForBroadcasterWithType (this, event_type))
+        if (unique && hijacking_listener_sp->PeekAtNextEventForBroadcasterWithType (&m_broadcaster, event_type))
             return;
-        hijacking_listener->AddEvent (event_sp);
+        hijacking_listener_sp->AddEvent (event_sp);
     }
     else
     {
@@ -264,7 +273,7 @@ Broadcaster::PrivateBroadcastEvent (EventSP &event_sp, bool unique)
             // put the new event on its event queue.
             if (event_type & pos->second)
             {
-                if (unique && pos->first->PeekAtNextEventForBroadcasterWithType (this, event_type))
+                if (unique && pos->first->PeekAtNextEventForBroadcasterWithType (&m_broadcaster, event_type))
                     continue;
                 pos->first->AddEvent (event_sp);
             }
@@ -273,36 +282,36 @@ Broadcaster::PrivateBroadcastEvent (EventSP &event_sp, bool unique)
 }
 
 void
-Broadcaster::BroadcastEvent (uint32_t event_type, EventData *event_data)
+Broadcaster::BroadcasterImpl::BroadcastEvent (uint32_t event_type, EventData *event_data)
 {
     EventSP event_sp (new Event (event_type, event_data));
     PrivateBroadcastEvent (event_sp, false);
 }
 
 void
-Broadcaster::BroadcastEventIfUnique (uint32_t event_type, EventData *event_data)
+Broadcaster::BroadcasterImpl::BroadcastEventIfUnique (uint32_t event_type, EventData *event_data)
 {
     EventSP event_sp (new Event (event_type, event_data));
     PrivateBroadcastEvent (event_sp, true);
 }
 
 bool
-Broadcaster::HijackBroadcaster (Listener *listener, uint32_t event_mask)
+Broadcaster::BroadcasterImpl::HijackBroadcaster (ListenerSP listener_sp, uint32_t event_mask)
 {
     Mutex::Locker event_types_locker(m_listeners_mutex);
 
     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS));
     if (log)
         log->Printf ("%p Broadcaster(\"%s\")::HijackBroadcaster (listener(\"%s\")=%p)",
-                     static_cast<void*>(this), m_broadcaster_name.AsCString(""),
-                     listener->m_name.c_str(), static_cast<void*>(listener));
-    m_hijacking_listeners.push_back(listener);
+                     static_cast<void*>(this), GetBroadcasterName(),
+                     listener_sp->m_name.c_str(), static_cast<void*>(listener_sp.get()));
+    m_hijacking_listeners.push_back(listener_sp);
     m_hijacking_masks.push_back(event_mask);
     return true;
 }
 
 bool
-Broadcaster::IsHijackedForEvent (uint32_t event_mask)
+Broadcaster::BroadcasterImpl::IsHijackedForEvent (uint32_t event_mask)
 {
     Mutex::Locker event_types_locker(m_listeners_mutex);
 
@@ -311,8 +320,21 @@ Broadcaster::IsHijackedForEvent (uint32_t event_mask)
     return false;
 }
 
+const char *
+Broadcaster::BroadcasterImpl::GetHijackingListenerName()
+{
+    if (m_hijacking_listeners.size())
+    {
+        return m_hijacking_listeners.back()->GetName();
+    }
+    else
+    {
+        return nullptr;
+    }
+}
+
 void
-Broadcaster::RestoreBroadcaster ()
+Broadcaster::BroadcasterImpl::RestoreBroadcaster ()
 {
     Mutex::Locker event_types_locker(m_listeners_mutex);
 
@@ -321,11 +343,11 @@ Broadcaster::RestoreBroadcaster ()
         Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EVENTS));
         if (log)
         {
-            Listener *listener = m_hijacking_listeners.back();
+            ListenerSP listener_sp = m_hijacking_listeners.back();
             log->Printf ("%p Broadcaster(\"%s\")::RestoreBroadcaster (about to pop listener(\"%s\")=%p)",
                          static_cast<void*>(this),
-                         m_broadcaster_name.AsCString(""),
-                         listener->m_name.c_str(), static_cast<void*>(listener));
+                         GetBroadcasterName(),
+                         listener_sp->m_name.c_str(), static_cast<void*>(listener_sp.get()));
         }
         m_hijacking_listeners.pop_back();
     }
@@ -363,8 +385,14 @@ BroadcasterManager::BroadcasterManager() :
 {
 }
 
+lldb::BroadcasterManagerSP
+BroadcasterManager::MakeBroadcasterManager()
+{
+    return BroadcasterManagerSP(new BroadcasterManager());
+}
+
 uint32_t
-BroadcasterManager::RegisterListenerForEvents (Listener &listener, BroadcastEventSpec event_spec)
+BroadcasterManager::RegisterListenerForEvents (ListenerSP listener_sp, BroadcastEventSpec event_spec)
 {
     Mutex::Locker locker(m_manager_mutex);
     
@@ -380,23 +408,23 @@ BroadcasterManager::RegisterListenerForEvents (Listener &listener, BroadcastEven
     
     if (available_bits != 0)
     {
-        m_event_map.insert (event_listener_key (BroadcastEventSpec (event_spec.GetBroadcasterClass(), available_bits), &listener));
-        m_listeners.insert(&listener);
+        m_event_map.insert (event_listener_key (BroadcastEventSpec (event_spec.GetBroadcasterClass(), available_bits), listener_sp));
+        m_listeners.insert(listener_sp);
     }
     
     return available_bits;
 }
 
 bool
-BroadcasterManager::UnregisterListenerForEvents (Listener &listener, BroadcastEventSpec event_spec)
+BroadcasterManager::UnregisterListenerForEvents (ListenerSP listener_sp, BroadcastEventSpec event_spec)
 {
     Mutex::Locker locker(m_manager_mutex);
     bool removed_some = false;
     
-    if (m_listeners.erase(&listener) == 0)
+    if (m_listeners.erase(listener_sp) == 0)
         return false;
     
-    ListenerMatchesAndSharedBits predicate (event_spec, listener);
+    ListenerMatchesAndSharedBits predicate (event_spec, listener_sp);
     std::vector<BroadcastEventSpec> to_be_readded;
     uint32_t event_bits_to_remove = event_spec.GetEventBits();
     
@@ -426,13 +454,13 @@ BroadcasterManager::UnregisterListenerForEvents (Listener &listener, BroadcastEv
     // Okay now add back the bits that weren't completely removed:
     for (size_t i = 0; i < to_be_readded.size(); i++)
     {
-        m_event_map.insert (event_listener_key (to_be_readded[i], &listener));
+        m_event_map.insert (event_listener_key (to_be_readded[i], listener_sp));
     }
     
     return removed_some;
 }
     
-Listener *
+ListenerSP
 BroadcasterManager::GetListenerForEventSpec (BroadcastEventSpec event_spec) const
 {
     Mutex::Locker locker(*(const_cast<Mutex *> (&m_manager_mutex)));
@@ -446,12 +474,34 @@ BroadcasterManager::GetListenerForEventSpec (BroadcastEventSpec event_spec) cons
 }
 
 void
-BroadcasterManager::RemoveListener (Listener &listener)
+BroadcasterManager::RemoveListener(Listener *listener)
+{
+    Mutex::Locker locker(m_manager_mutex);
+    ListenerMatchesPointer predicate (listener);
+    listener_collection::iterator iter = m_listeners.begin(), end_iter = m_listeners.end();
+    
+    std::find_if (iter, end_iter, predicate);
+    if (iter != end_iter)
+        m_listeners.erase(iter);
+    
+    while (true)
+    {
+        collection::iterator iter, end_iter = m_event_map.end();
+        iter = find_if (m_event_map.begin(), end_iter, predicate);
+        if (iter == end_iter)
+            break;
+        else
+            m_event_map.erase(iter);
+    }    
+}
+
+void
+BroadcasterManager::RemoveListener (ListenerSP listener_sp)
 {
     Mutex::Locker locker(m_manager_mutex);
-    ListenerMatches predicate (listener);
+    ListenerMatches predicate (listener_sp);
 
-    if (m_listeners.erase (&listener) == 0)
+    if (m_listeners.erase (listener_sp) == 0)
         return;
         
     while (true)
@@ -487,7 +537,7 @@ BroadcasterManager::Clear ()
     listener_collection::iterator end_iter = m_listeners.end();
     
     for (listener_collection::iterator iter = m_listeners.begin(); iter != end_iter; iter++)
-        (*iter)->BroadcasterManagerWillDestruct(this);
+        (*iter)->BroadcasterManagerWillDestruct(this->shared_from_this());
     m_listeners.clear();
     m_event_map.clear();
 }