[lldb][NFCI] Remove use of ConstString from Listener

[bulbazord]

Summary

The only place ConstString was used in Listener was for filtering
broadcasters by name when looking for the next event. This functionality
is completely unused from what I can tell (even in downstream forks).

[jingham]

LGTM, if no one has found a use for this way of filtering by this point, there probably isn't a good one.

lldb/include/lldb/Utility/Listener.h

 #include <ratio>
 #include <string>
 #include <vector>
 
 #include <cstddef>
 #include <cstdint>
 
 namespace lldb_private {
-class ConstString;
 class Event;
 }
 
 namespace lldb_private {
 
 class Listener : public std::enable_shared_from_this<Listener> {
 public:
   typedef bool (*HandleBroadcastCallback)(lldb::EventSP &event_sp, void *baton);
typedef std::multimap<Broadcaster::BroadcasterImplWP, BroadcasterInfo,
       broadcaster_collection;
   typedef std::list<lldb::EventSP> event_collection;
   typedef std::vector<lldb::BroadcasterManagerWP>
       broadcaster_manager_collection;
 
   bool
   FindNextEventInternal(std::unique_lock<std::mutex> &lock,
                         Broadcaster *broadcaster, // nullptr for any broadcaster
-                        const ConstString *sources, // nullptr for any event
-                        uint32_t num_sources, uint32_t event_type_mask,
-                        lldb::EventSP &event_sp, bool remove);
+                        uint32_t event_type_mask, lldb::EventSP &event_sp,
+                        bool remove);
 
   bool GetEventInternal(const Timeout<std::micro> &timeout,
                         Broadcaster *broadcaster, // nullptr for any broadcaster
-                        const ConstString *sources, // nullptr for any event
-                        uint32_t num_sources, uint32_t event_type_mask,
-                        lldb::EventSP &event_sp);
+                        uint32_t event_type_mask, lldb::EventSP &event_sp);
 
   std::string m_name;
   broadcaster_collection m_broadcasters;
   std::recursive_mutex m_broadcasters_mutex; // Protects m_broadcasters
   event_collection m_events;
   std::mutex m_events_mutex; // Protects m_broadcasters and m_events
   std::condition_variable m_events_condition;
   broadcaster_manager_collection m_broadcaster_managers;

lldb/source/Utility/Listener.cpp

 //===-- Listener.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Utility/Listener.h"
 #include "lldb/Utility/Broadcaster.h"
-#include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/LLDBLog.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
 using namespace lldb;
public:
   }
 
 private:
   Broadcaster *m_broadcaster;
 };
 
 class EventMatcher {
 public:
-  EventMatcher(Broadcaster *broadcaster, const ConstString *broadcaster_names,
-               uint32_t num_broadcaster_names, uint32_t event_type_mask)
-      : m_broadcaster(broadcaster), m_broadcaster_names(broadcaster_names),
-        m_num_broadcaster_names(num_broadcaster_names),
-        m_event_type_mask(event_type_mask) {}
+  EventMatcher(Broadcaster *broadcaster, uint32_t event_type_mask)
+      : m_broadcaster(broadcaster), m_event_type_mask(event_type_mask) {}
 
   bool operator()(const EventSP &event_sp) const {
     if (m_broadcaster && !event_sp->BroadcasterIs(m_broadcaster))
       return false;
 
-    if (m_broadcaster_names) {
-      bool found_source = false;
-      const llvm::StringRef event_broadcaster_name =
-          event_sp->GetBroadcaster()->GetBroadcasterName();
-      for (uint32_t i = 0; i < m_num_broadcaster_names; ++i) {
-        if (m_broadcaster_names[i] == event_broadcaster_name) {
-          found_source = true;
-          break;
-        }
-      }
-      if (!found_source)
-        return false;
-    }
-
     return m_event_type_mask == 0 || m_event_type_mask & event_sp->GetType();
   }
 
 private:
   Broadcaster *m_broadcaster;
-  const ConstString *m_broadcaster_names;
-  const uint32_t m_num_broadcaster_names;
   const uint32_t m_event_type_mask;
 };
 
 bool Listener::FindNextEventInternal(
     std::unique_lock<std::mutex> &lock,
-    Broadcaster *broadcaster,             // nullptr for any broadcaster
-    const ConstString *broadcaster_names, // nullptr for any event
-    uint32_t num_broadcaster_names, uint32_t event_type_mask, EventSP &event_sp,
-    bool remove) {
+    Broadcaster *broadcaster, // nullptr for any broadcaster
+    uint32_t event_type_mask, EventSP &event_sp, bool remove) {
   // NOTE: callers of this function must lock m_events_mutex using a
   // Mutex::Locker
   // and pass the locker as the first argument. m_events_mutex is no longer
   // recursive.
   Log *log = GetLog(LLDBLog::Events);
 
   if (m_events.empty())
     return false;
 
   Listener::event_collection::iterator pos = m_events.end();
 
-  if (broadcaster == nullptr && broadcaster_names == nullptr &&
-      event_type_mask == 0) {
+  if (broadcaster == nullptr && event_type_mask == 0) {
     pos = m_events.begin();
   } else {
     pos = std::find_if(m_events.begin(), m_events.end(),
-                       EventMatcher(broadcaster, broadcaster_names,
-                                    num_broadcaster_names, event_type_mask));
+                       EventMatcher(broadcaster, event_type_mask));
   }
 
   if (pos != m_events.end()) {
     event_sp = *pos;
 
     if (log != nullptr)
       LLDB_LOGF(log,
                 "%p '%s' Listener::FindNextEventInternal(broadcaster=%p, "
-                "broadcaster_names=%p[%u], event_type_mask=0x%8.8x, "
+                "event_type_mask=0x%8.8x, "
                 "remove=%i) event %p",
                 static_cast<void *>(this), GetName(),
-                static_cast<void *>(broadcaster),
-                static_cast<const void *>(broadcaster_names),
-                num_broadcaster_names, event_type_mask, remove,
+                static_cast<void *>(broadcaster), event_type_mask, remove,
                 static_cast<void *>(event_sp.get()));
 
     if (remove) {
       m_events.erase(pos);
       // Unlock the event queue here.  We've removed this event and are about
       // to return it so it should be okay to get the next event off the queue
       // here - and it might be useful to do that in the "DoOnRemoval".
       lock.unlock();
       if (!m_is_shadow)
         event_sp->DoOnRemoval();
     }
     return true;
   }
 
   event_sp.reset();
   return false;
 }
 
 Event *Listener::PeekAtNextEvent() {
   std::unique_lock<std::mutex> guard(m_events_mutex);
   EventSP event_sp;
-  if (FindNextEventInternal(guard, nullptr, nullptr, 0, 0, event_sp, false))
+  if (FindNextEventInternal(guard, nullptr, 0, event_sp, false))
     return event_sp.get();
   return nullptr;
 }
 
 Event *Listener::PeekAtNextEventForBroadcaster(Broadcaster *broadcaster) {
   std::unique_lock<std::mutex> guard(m_events_mutex);
   EventSP event_sp;
-  if (FindNextEventInternal(guard, broadcaster, nullptr, 0, 0, event_sp, false))
+  if (FindNextEventInternal(guard, broadcaster, 0, event_sp, false))
     return event_sp.get();
   return nullptr;
 }
 
 Event *
 Listener::PeekAtNextEventForBroadcasterWithType(Broadcaster *broadcaster,
                                                 uint32_t event_type_mask) {
   std::unique_lock<std::mutex> guard(m_events_mutex);
   EventSP event_sp;
-  if (FindNextEventInternal(guard, broadcaster, nullptr, 0, event_type_mask,
-                            event_sp, false))
+  if (FindNextEventInternal(guard, broadcaster, event_type_mask, event_sp,
+                            false))
     return event_sp.get();
   return nullptr;
 }
 
 bool Listener::GetEventInternal(
     const Timeout<std::micro> &timeout,
-    Broadcaster *broadcaster,             // nullptr for any broadcaster
-    const ConstString *broadcaster_names, // nullptr for any event
-    uint32_t num_broadcaster_names, uint32_t event_type_mask,
-    EventSP &event_sp) {
+    Broadcaster *broadcaster, // nullptr for any broadcaster
+    uint32_t event_type_mask, EventSP &event_sp) {
   Log *log = GetLog(LLDBLog::Events);
   LLDB_LOG(log, "this = {0}, timeout = {1} for {2}", this, timeout, m_name);
 
   std::unique_lock<std::mutex> lock(m_events_mutex);
 
   while (true) {
-    if (FindNextEventInternal(lock, broadcaster, broadcaster_names,
-                              num_broadcaster_names, event_type_mask, event_sp,
+    if (FindNextEventInternal(lock, broadcaster, event_type_mask, event_sp,
                               true)) {
       return true;
     } else {
       std::cv_status result = std::cv_status::no_timeout;
       if (!timeout)
         m_events_condition.wait(lock);
       else
         result = m_events_condition.wait_for(lock, *timeout);
bool Listener::GetEventInternal(
   }
 
   return false;
 }
 
 bool Listener::GetEventForBroadcasterWithType(
     Broadcaster *broadcaster, uint32_t event_type_mask, EventSP &event_sp,
     const Timeout<std::micro> &timeout) {
-  return GetEventInternal(timeout, broadcaster, nullptr, 0, event_type_mask,
-                          event_sp);
+  return GetEventInternal(timeout, broadcaster, event_type_mask, event_sp);
 }
 
 bool Listener::GetEventForBroadcaster(Broadcaster *broadcaster,
                                       EventSP &event_sp,
                                       const Timeout<std::micro> &timeout) {
-  return GetEventInternal(timeout, broadcaster, nullptr, 0, 0, event_sp);
+  return GetEventInternal(timeout, broadcaster, 0, event_sp);
 }
 
 bool Listener::GetEvent(EventSP &event_sp, const Timeout<std::micro> &timeout) {
-  return GetEventInternal(timeout, nullptr, nullptr, 0, 0, event_sp);
+  return GetEventInternal(timeout, nullptr, 0, event_sp);
 }
 
 size_t Listener::HandleBroadcastEvent(EventSP &event_sp) {
   size_t num_handled = 0;
   std::lock_guard<std::recursive_mutex> guard(m_broadcasters_mutex);
   Broadcaster *broadcaster = event_sp->GetBroadcaster();
   if (!broadcaster)
     return 0;