Use Timeout<> in the Listener class

[labath]

Summary

Communication classes use the Timeout<> class to specify the timeout. Listener
class was converted to chrono some time ago, but it used a different meaning for
a timeout of zero (Listener: infinite wait, Communication: no wait). Instead,
Listener provided separate functions which performed a non-blocking event read.

This converts the Listener class to the new Timeout class, to improve
consistency. It also allows us to get merge the different GetNextEvent* and
WaitForEvent* functions into one. No functional change intended.

lldb/trunk/include/lldb/Core/Listener.h

 #include <map>
 #include <mutex>
 #include <string>
 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Event.h"
+#include "lldb/Utility/Timeout.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 class Listener : public std::enable_shared_from_this<Listener> {
 public:
   typedef bool (*HandleBroadcastCallback)(lldb::EventSP &event_sp, void *baton);
 
public:
 
   uint32_t StartListeningForEvents(Broadcaster *broadcaster,
                                    uint32_t event_mask,
                                    HandleBroadcastCallback callback,
                                    void *callback_user_data);
 
   bool StopListeningForEvents(Broadcaster *broadcaster, uint32_t event_mask);
 
-  // Returns true if an event was received, false if we timed out.
-  bool WaitForEvent(const std::chrono::microseconds &timeout,
-                    lldb::EventSP &event_sp);
-
-  bool WaitForEventForBroadcaster(const std::chrono::microseconds &timeout,
-                                  Broadcaster *broadcaster,
-                                  lldb::EventSP &event_sp);
-
-  bool WaitForEventForBroadcasterWithType(
-      const std::chrono::microseconds &timeout, Broadcaster *broadcaster,
-      uint32_t event_type_mask, lldb::EventSP &event_sp);
-
   Event *PeekAtNextEvent();
 
   Event *PeekAtNextEventForBroadcaster(Broadcaster *broadcaster);
 
   Event *PeekAtNextEventForBroadcasterWithType(Broadcaster *broadcaster,
                                                uint32_t event_type_mask);
 
-  bool GetNextEvent(lldb::EventSP &event_sp);
+  // Returns true if an event was received, false if we timed out.
+  bool GetEvent(lldb::EventSP &event_sp, const Timeout<std::micro> &timeout);
 
-  bool GetNextEventForBroadcaster(Broadcaster *broadcaster,
-                                  lldb::EventSP &event_sp);
+  bool GetEventForBroadcaster(Broadcaster *broadcaster, lldb::EventSP &event_sp,
+                              const Timeout<std::micro> &timeout);
 
-  bool GetNextEventForBroadcasterWithType(Broadcaster *broadcaster,
-                                          uint32_t event_type_mask,
-                                          lldb::EventSP &event_sp);
+  bool GetEventForBroadcasterWithType(Broadcaster *broadcaster,
+                                      lldb::EventSP &event_sp,
+                                      const Timeout<std::micro> &timeout);
 
   size_t HandleBroadcastEvent(lldb::EventSP &event_sp);
 
 private:
   //------------------------------------------------------------------
   // Classes that inherit from Listener can see and modify these
   //------------------------------------------------------------------
   struct BroadcasterInfo {
private:
 
   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);
 
-  bool
-  GetNextEventInternal(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
-  WaitForEventsInternal(const std::chrono::microseconds &timeout,
+  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);
 
   std::string m_name;
   broadcaster_collection m_broadcasters;
   std::recursive_mutex m_broadcasters_mutex; // Protects m_broadcasters

lldb/trunk/source/API/SBDebugger.cpp

if (GetOutputFileHandle() != nullptr)
       result.PutOutput(GetOutputFileHandle());
 
     if (!m_opaque_sp->GetAsyncExecution()) {
       SBProcess process(GetCommandInterpreter().GetProcess());
       ProcessSP process_sp(process.GetSP());
       if (process_sp) {
         EventSP event_sp;
         ListenerSP lldb_listener_sp = m_opaque_sp->GetListener();
-        while (lldb_listener_sp->GetNextEventForBroadcaster(process_sp.get(),
-                                                            event_sp)) {
+        while (lldb_listener_sp->GetEventForBroadcaster(
+            process_sp.get(), event_sp, std::chrono::seconds(0))) {
           SBEvent event(event_sp);
           HandleProcessEvent(process, event, GetOutputFileHandle(),
                              GetErrorFileHandle());
         }
       }
     }
   }
 }

lldb/trunk/source/API/SBListener.cpp

if (timeout_secs == UINT32_MAX) {
           "SBListener(%p)::WaitForEvent (timeout_secs=%d, SBEvent(%p))...",
           static_cast<void *>(m_opaque_sp.get()), timeout_secs,
           static_cast<void *>(event.get()));
     }
   }
   bool success = false;
 
   if (m_opaque_sp) {
-    std::chrono::microseconds timeout = std::chrono::microseconds(0);
+    Timeout<std::micro> timeout(llvm::None);
     if (timeout_secs != UINT32_MAX) {
       assert(timeout_secs != 0); // Take this out after all calls with timeout
                                  // set to zero have been removed....
       timeout = std::chrono::seconds(timeout_secs);
     }
     EventSP event_sp;
-    if (m_opaque_sp->WaitForEvent(timeout, event_sp)) {
+    if (m_opaque_sp->GetEvent(event_sp, timeout)) {
       event.reset(event_sp);
       success = true;
     }
   }
 
   if (log) {
     if (timeout_secs == UINT32_MAX) {
       log->Printf("SBListener(%p)::WaitForEvent (timeout_secs=INFINITE, "
if (!success)
     event.reset(NULL);
   return success;
 }
 
 bool SBListener::WaitForEventForBroadcaster(uint32_t num_seconds,
                                             const SBBroadcaster &broadcaster,
                                             SBEvent &event) {
   if (m_opaque_sp && broadcaster.IsValid()) {
-    std::chrono::microseconds timeout = std::chrono::microseconds(0);
+    Timeout<std::micro> timeout(llvm::None);
     if (num_seconds != UINT32_MAX)
       timeout = std::chrono::seconds(num_seconds);
     EventSP event_sp;
-    if (m_opaque_sp->WaitForEventForBroadcaster(timeout, broadcaster.get(),
-                                                event_sp)) {
+    if (m_opaque_sp->GetEventForBroadcaster(broadcaster.get(), event_sp,
+                                            timeout)) {
       event.reset(event_sp);
       return true;
     }
   }
   event.reset(NULL);
   return false;
 }
 
 bool SBListener::WaitForEventForBroadcasterWithType(
     uint32_t num_seconds, const SBBroadcaster &broadcaster,
     uint32_t event_type_mask, SBEvent &event) {
   if (m_opaque_sp && broadcaster.IsValid()) {
-    std::chrono::microseconds timeout = std::chrono::microseconds(0);
+    Timeout<std::micro> timeout(llvm::None);
     if (num_seconds != UINT32_MAX)
       timeout = std::chrono::seconds(num_seconds);
     EventSP event_sp;
-    if (m_opaque_sp->WaitForEventForBroadcasterWithType(
-            timeout, broadcaster.get(), event_type_mask, event_sp)) {
+    if (m_opaque_sp->GetEventForBroadcasterWithType(
+            broadcaster.get(), event_type_mask, event_sp, timeout)) {
       event.reset(event_sp);
       return true;
     }
   }
   event.reset(NULL);
   return false;
 }
 
bool SBListener::PeekAtNextEventForBroadcasterWithType(
   }
   event.reset(NULL);
   return false;
 }
 
 bool SBListener::GetNextEvent(SBEvent &event) {
   if (m_opaque_sp) {
     EventSP event_sp;
-    if (m_opaque_sp->GetNextEvent(event_sp)) {
+    if (m_opaque_sp->GetEvent(event_sp, std::chrono::seconds(0))) {
       event.reset(event_sp);
       return true;
     }
   }
   event.reset(NULL);
   return false;
 }
 
 bool SBListener::GetNextEventForBroadcaster(const SBBroadcaster &broadcaster,
                                             SBEvent &event) {
   if (m_opaque_sp && broadcaster.IsValid()) {
     EventSP event_sp;
-    if (m_opaque_sp->GetNextEventForBroadcaster(broadcaster.get(), event_sp)) {
+    if (m_opaque_sp->GetEventForBroadcaster(broadcaster.get(), event_sp,
+                                            std::chrono::seconds(0))) {
       event.reset(event_sp);
       return true;
     }
   }
   event.reset(NULL);
   return false;
 }
 
 bool SBListener::GetNextEventForBroadcasterWithType(
     const SBBroadcaster &broadcaster, uint32_t event_type_mask,
     SBEvent &event) {
   if (m_opaque_sp && broadcaster.IsValid()) {
     EventSP event_sp;
-    if (m_opaque_sp->GetNextEventForBroadcasterWithType(
-            broadcaster.get(), event_type_mask, event_sp)) {
+    if (m_opaque_sp->GetEventForBroadcasterWithType(broadcaster.get(),
+                                                    event_type_mask, event_sp,
+                                                    std::chrono::seconds(0))) {
       event.reset(event_sp);
       return true;
     }
   }
   event.reset(NULL);
   return false;
 }
 

lldb/trunk/source/Core/Communication.cpp

 
 bool Communication::HasConnection() const {
   return m_connection_sp.get() != nullptr;
 }
 
 size_t Communication::Read(void *dst, size_t dst_len,
                            const Timeout<std::micro> &timeout,
                            ConnectionStatus &status, Error *error_ptr) {
-  using std::chrono::microseconds;
-
   lldb_private::LogIfAnyCategoriesSet(
       LIBLLDB_LOG_COMMUNICATION,
       "%p Communication::Read (dst = %p, dst_len = %" PRIu64
       ", timeout = %u usec) connection = %p",
       this, dst, (uint64_t)dst_len, timeout ? timeout->count() : -1,
       m_connection_sp.get());
 
   if (m_read_thread_enabled) {
if (!m_connection_sp) {
       status = eConnectionStatusNoConnection;
       return 0;
     }
 
     ListenerSP listener_sp(Listener::MakeListener("Communication::Read"));
     listener_sp->StartListeningForEvents(
         this, eBroadcastBitReadThreadGotBytes | eBroadcastBitReadThreadDidExit);
     EventSP event_sp;
-    microseconds listener_timeout =
-        timeout ? microseconds(*timeout) : microseconds(0);
-    while (listener_sp->WaitForEvent(listener_timeout, event_sp)) {
+    while (listener_sp->GetEvent(event_sp, timeout)) {
       const uint32_t event_type = event_sp->GetType();
       if (event_type & eBroadcastBitReadThreadGotBytes) {
         return GetCachedBytes(dst, dst_len);
       }
 
       if (event_type & eBroadcastBitReadThreadDidExit) {
         if (GetCloseOnEOF())
           Disconnect(nullptr);
void Communication::SynchronizeWithReadThread() {
   if (!m_read_thread_enabled || m_read_thread_did_exit)
     return;
 
   // Notify the read thread.
   m_connection_sp->InterruptRead();
 
   // Wait for the synchronization event.
   EventSP event_sp;
-  listener_sp->WaitForEvent(std::chrono::microseconds(0), event_sp);
+  listener_sp->GetEvent(event_sp, llvm::None);
 }
 
 void Communication::SetConnection(Connection *connection) {
   Disconnect(nullptr);
   StopReadThread(nullptr);
   m_connection_sp.reset(connection);
 }
 

lldb/trunk/source/Core/Debugger.cpp

void Debugger::DefaultEventHandler() {
 
   // Let the thread that spawned us know that we have started up and
   // that we are now listening to all required events so no events get missed
   m_sync_broadcaster.BroadcastEvent(eBroadcastBitEventThreadIsListening);
 
   bool done = false;
   while (!done) {
     EventSP event_sp;
-    if (listener_sp->WaitForEvent(std::chrono::microseconds(0), event_sp)) {
+    if (listener_sp->GetEvent(event_sp, llvm::None)) {
       if (event_sp) {
         Broadcaster *broadcaster = event_sp->GetBroadcaster();
         if (broadcaster) {
           uint32_t event_type = event_sp->GetType();
           ConstString broadcaster_class(broadcaster->GetBroadcasterClass());
           if (broadcaster_class == broadcaster_class_process) {
             HandleProcessEvent(event_sp);
           } else if (broadcaster_class == broadcaster_class_target) {
if (!m_event_handler_thread.IsJoinable()) {
     // Make sure DefaultEventHandler() is running and listening to events before
     // we return
     // from this function. We are only listening for events of type
     // eBroadcastBitEventThreadIsListening so we don't need to check the event,
     // we just need
     // to wait an infinite amount of time for it (nullptr timeout as the first
     // parameter)
     lldb::EventSP event_sp;
-    listener_sp->WaitForEvent(std::chrono::microseconds(0), event_sp);
+    listener_sp->GetEvent(event_sp, llvm::None);
   }
   return m_event_handler_thread.IsJoinable();
 }
 
 void Debugger::StopEventHandlerThread() {
   if (m_event_handler_thread.IsJoinable()) {
     GetCommandInterpreter().BroadcastEvent(
         CommandInterpreter::eBroadcastBitQuitCommandReceived);

lldb/trunk/source/Core/IOHandler.cpp

 #endif
       if (ch == -1) {
         if (feof(m_in) || ferror(m_in)) {
           done = true;
         } else {
           // Just a timeout from using halfdelay(), check for events
           EventSP event_sp;
           while (listener_sp->PeekAtNextEvent()) {
-            listener_sp->GetNextEvent(event_sp);
+            listener_sp->GetEvent(event_sp, std::chrono::seconds(0));
 
             if (event_sp) {
               Broadcaster *broadcaster = event_sp->GetBroadcaster();
               if (broadcaster) {
                 // uint32_t event_type = event_sp->GetType();
                 ConstString broadcaster_class(
                     broadcaster->GetBroadcasterClass());
                 if (broadcaster_class == broadcaster_class_process) {

lldb/trunk/source/Core/Listener.cpp

Listener::PeekAtNextEventForBroadcasterWithType(Broadcaster *broadcaster,
   std::unique_lock<std::mutex> guard(m_events_mutex);
   EventSP event_sp;
   if (FindNextEventInternal(guard, broadcaster, nullptr, 0, event_type_mask,
                             event_sp, false))
     return event_sp.get();
   return nullptr;
 }
 
-bool Listener::GetNextEventInternal(
-    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) {
-  std::unique_lock<std::mutex> guard(m_events_mutex);
-  return FindNextEventInternal(guard, broadcaster, broadcaster_names,
-                               num_broadcaster_names, event_type_mask, event_sp,
-                               true);
-}
-
-bool Listener::GetNextEvent(EventSP &event_sp) {
-  return GetNextEventInternal(nullptr, nullptr, 0, 0, event_sp);
-}
-
-bool Listener::GetNextEventForBroadcaster(Broadcaster *broadcaster,
-                                          EventSP &event_sp) {
-  return GetNextEventInternal(broadcaster, nullptr, 0, 0, event_sp);
-}
-
-bool Listener::GetNextEventForBroadcasterWithType(Broadcaster *broadcaster,
-                                                  uint32_t event_type_mask,
-                                                  EventSP &event_sp) {
-  return GetNextEventInternal(broadcaster, nullptr, 0, event_type_mask,
-                              event_sp);
-}
-
-bool Listener::WaitForEventsInternal(
-    const std::chrono::microseconds &timeout,
+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) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
   if (log != nullptr)
-    log->Printf("%p Listener::WaitForEventsInternal (timeout = %llu us) for %s",
-                static_cast<void *>(this),
-                static_cast<unsigned long long>(timeout.count()),
+    log->Printf("%p Listener::GetEventInternal (timeout = %llu us) for %s",
+                static_cast<void *>(this), static_cast<unsigned long long>(
+                                               timeout ? timeout->count() : -1),
                 m_name.c_str());
 
   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,
                               true)) {
       return true;
     } else {
       std::cv_status result = std::cv_status::no_timeout;
-      if (timeout == std::chrono::microseconds(0))
+      if (!timeout)
         m_events_condition.wait(lock);
       else
-        result = m_events_condition.wait_for(lock, timeout);
+        result = m_events_condition.wait_for(lock, *timeout);
 
       if (result == std::cv_status::timeout) {
         log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS);
         if (log)
-          log->Printf("%p Listener::WaitForEventsInternal() timed out for %s",
+          log->Printf("%p Listener::GetEventInternal() timed out for %s",
                       static_cast<void *>(this), m_name.c_str());
         return false;
       } else if (result != std::cv_status::no_timeout) {
         log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS);
         if (log)
-          log->Printf(
-              "%p Listener::WaitForEventsInternal() unknown error for %s",
+          log->Printf("%p Listener::GetEventInternal() unknown error for %s",
                       static_cast<void *>(this), m_name.c_str());
         return false;
       }
     }
   }
 
   return false;
 }
 
-bool Listener::WaitForEventForBroadcasterWithType(
-    const std::chrono::microseconds &timeout, Broadcaster *broadcaster,
-    uint32_t event_type_mask, EventSP &event_sp) {
-  return WaitForEventsInternal(timeout, broadcaster, nullptr, 0,
-                               event_type_mask, event_sp);
+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);
 }
 
-bool Listener::WaitForEventForBroadcaster(
-    const std::chrono::microseconds &timeout, Broadcaster *broadcaster,
-    EventSP &event_sp) {
-  return WaitForEventsInternal(timeout, broadcaster, nullptr, 0, 0, event_sp);
+bool Listener::GetEventForBroadcaster(Broadcaster *broadcaster,
+                                      EventSP &event_sp,
+                                      const Timeout<std::micro> &timeout) {
+  return GetEventInternal(timeout, broadcaster, nullptr, 0, 0, event_sp);
 }
 
-bool Listener::WaitForEvent(const std::chrono::microseconds &timeout,
-                            EventSP &event_sp) {
-  return WaitForEventsInternal(timeout, nullptr, nullptr, 0, 0, event_sp);
+bool Listener::GetEvent(EventSP &event_sp, const Timeout<std::micro> &timeout) {
+  return GetEventInternal(timeout, nullptr, nullptr, 0, 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;

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

if (continue_packet_error) {
         return error;
       }
 
       m_async_broadcaster.BroadcastEvent(
           eBroadcastBitAsyncContinue,
           new EventDataBytes(continue_packet.GetString().data(),
                              continue_packet.GetSize()));
 
-      if (listener_sp->WaitForEvent(std::chrono::seconds(5), event_sp) ==
-          false) {
+      if (listener_sp->GetEvent(event_sp, std::chrono::seconds(5)) == false) {
         error.SetErrorString("Resume timed out.");
         if (log)
           log->Printf("ProcessGDBRemote::DoResume: Resume timed out.");
       } else if (event_sp->BroadcasterIs(&m_async_broadcaster)) {
         error.SetErrorString("Broadcast continue, but the async thread was "
                              "killed before we got an ack back.");
         if (log)
           log->Printf("ProcessGDBRemote::DoResume: Broadcast continue, but the "
thread_result_t ProcessGDBRemote::AsyncThread(void *arg) {
 
   EventSP event_sp;
   bool done = false;
   while (!done) {
     if (log)
       log->Printf("ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64
                   ") listener.WaitForEvent (NULL, event_sp)...",
                   __FUNCTION__, arg, process->GetID());
-    if (process->m_async_listener_sp->WaitForEvent(std::chrono::microseconds(0),
-                                                   event_sp)) {
+    if (process->m_async_listener_sp->GetEvent(event_sp, llvm::None)) {
       const uint32_t event_type = event_sp->GetType();
       if (event_sp->BroadcasterIs(&process->m_async_broadcaster)) {
         if (log)
           log->Printf("ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64
                       ") Got an event of type: %d...",
                       __FUNCTION__, arg, process->GetID(), event_type);
 
         switch (event_type) {

lldb/trunk/source/Target/Process.cpp

 #include "lldb/Target/ThreadPlanBase.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/NameMatches.h"
 #include "lldb/Utility/SelectHelper.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
+// A temporary function to convert between old representations of timeouts (0
+// means infinite wait) and new Timeout class (0 means "poll").
+// TODO(labath): Fix up all callers and remove this.
+static Timeout<std::micro> ConvertTimeout(std::chrono::microseconds t) {
+  if (t == std::chrono::microseconds(0))
+    return llvm::None;
+  return t;
+}
+
 // Comment out line below to disable memory caching, overriding the process
 // setting
 // target.process.disable-memory-cache
 #define ENABLE_MEMORY_CACHING
 
 #ifdef ENABLE_MEMORY_CACHING
 #define DISABLE_MEM_CACHE_DEFAULT false
 #else

 // waiting for new events, so if we needed more than one event for our handling,
 // we would
 // stall.  So instead we do it when we fetch the event off of the queue.
 //
 
 StateType Process::GetNextEvent(EventSP &event_sp) {
   StateType state = eStateInvalid;
 
-  if (m_listener_sp->GetNextEventForBroadcaster(this, event_sp) && event_sp)
+  if (m_listener_sp->GetEventForBroadcaster(this, event_sp,
+                                            std::chrono::seconds(0)) &&
+      event_sp)
     state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
 
   return state;
 }
 
 void Process::SyncIOHandler(uint32_t iohandler_id, uint64_t timeout_msec) {
   // don't sync (potentially context switch) in case where there is no process
   // IO
if (log)
     log->Printf("Process::%s (timeout = %llu, event_sp)...", __FUNCTION__,
                 static_cast<unsigned long long>(timeout.count()));
 
   ListenerSP listener_sp = hijack_listener_sp;
   if (!listener_sp)
     listener_sp = m_listener_sp;
 
   StateType state = eStateInvalid;
-  if (listener_sp->WaitForEventForBroadcasterWithType(
-          timeout, this, eBroadcastBitStateChanged | eBroadcastBitInterrupt,
-          event_sp)) {
+  if (listener_sp->GetEventForBroadcasterWithType(
+          this, eBroadcastBitStateChanged | eBroadcastBitInterrupt, event_sp,
+          ConvertTimeout(timeout))) {
     if (event_sp && event_sp->GetType() == eBroadcastBitStateChanged)
       state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
     else if (log)
       log->Printf("Process::%s got no event or was interrupted.", __FUNCTION__);
   }
 
   if (log)
     log->Printf("Process::%s (timeout = %llu, event_sp) => %s", __FUNCTION__,
StateType Process::WaitForStateChangedEventsPrivate(
     const std::chrono::microseconds &timeout, EventSP &event_sp) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
 
   if (log)
     log->Printf("Process::%s (timeout = %llu, event_sp)...", __FUNCTION__,
                 static_cast<unsigned long long>(timeout.count()));
 
   StateType state = eStateInvalid;
-  if (m_private_state_listener_sp->WaitForEventForBroadcasterWithType(
-          timeout, &m_private_state_broadcaster,
-          eBroadcastBitStateChanged | eBroadcastBitInterrupt, event_sp))
+  if (m_private_state_listener_sp->GetEventForBroadcasterWithType(
+          &m_private_state_broadcaster,
+          eBroadcastBitStateChanged | eBroadcastBitInterrupt, event_sp,
+          ConvertTimeout(timeout)))
     if (event_sp && event_sp->GetType() == eBroadcastBitStateChanged)
       state = Process::ProcessEventData::GetStateFromEvent(event_sp.get());
 
   // This is a bit of a hack, but when we wait here we could very well return
   // to the command-line, and that could disable the log, which would render the
   // log we got above invalid.
   if (log)
     log->Printf("Process::%s (timeout = %llu, event_sp) => %s", __FUNCTION__,
                 static_cast<unsigned long long>(timeout.count()),
                 state == eStateInvalid ? "TIMEOUT" : StateAsCString(state));
   return state;
 }
 
 bool Process::WaitForEventsPrivate(const std::chrono::microseconds &timeout,
                                    EventSP &event_sp, bool control_only) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
 
   if (log)
     log->Printf("Process::%s (timeout = %llu, event_sp)...", __FUNCTION__,
                 static_cast<unsigned long long>(timeout.count()));
 
   if (control_only)
-    return m_private_state_listener_sp->WaitForEventForBroadcaster(
-        timeout, &m_private_state_control_broadcaster, event_sp);
+    return m_private_state_listener_sp->GetEventForBroadcaster(
+        &m_private_state_control_broadcaster, event_sp,
+        ConvertTimeout(timeout));
   else
-    return m_private_state_listener_sp->WaitForEvent(timeout, event_sp);
+    return m_private_state_listener_sp->GetEvent(event_sp,
+                                                 ConvertTimeout(timeout));
 }
 
 bool Process::IsRunning() const {
   return StateIsRunningState(m_public_state.GetValue());
 }
 
 int Process::GetExitStatus() {
   std::lock_guard<std::mutex> guard(m_exit_status_mutex);
if (error.Success()) {
     m_os_ap.reset(OperatingSystem::FindPlugin(this, nullptr));
     // We successfully loaded a core file, now pretend we stopped so we can
     // show all of the threads in the core file and explore the crashed
     // state.
     SetPrivateState(eStateStopped);
 
     // Wait indefinitely for a stopped event since we just posted one above...
     lldb::EventSP event_sp;
-    listener_sp->WaitForEvent(std::chrono::microseconds(0), event_sp);
+    listener_sp->GetEvent(event_sp, llvm::None);
     StateType state = ProcessEventData::GetStateFromEvent(event_sp.get());
 
     if (!StateIsStoppedState(state, false)) {
       Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
       if (log)
         log->Printf("Process::Halt() failed to stop, state is: %s",
                     StateAsCString(state));
       error.SetErrorString(
while (true) {
                 eDiagnosticSeverityError,
                 "couldn't resume inferior the %d time: \"%s\".", num_resumes,
                 resume_error.AsCString());
             return_value = eExpressionSetupError;
             break;
           }
         }
 
-        got_event = listener_sp->WaitForEvent(std::chrono::microseconds(500000),
-                                              event_sp);
+        got_event =
+            listener_sp->GetEvent(event_sp, std::chrono::milliseconds(500));
         if (!got_event) {
           if (log)
             log->Printf("Process::RunThreadPlan(): didn't get any event after "
                         "resume %" PRIu32 ", exiting.",
                         num_resumes);
 
           diagnostic_manager.Printf(eDiagnosticSeverityError,
                                     "didn't get any event after resume %" PRIu32

 #ifdef LLDB_RUN_THREAD_HALT_WITH_EVENT
       // See comment above...
       if (miss_first_event) {
         usleep(1000);
         miss_first_event = false;
         got_event = false;
       } else
 #endif
-        got_event = listener_sp->WaitForEvent(timeout, event_sp);
+        got_event = listener_sp->GetEvent(event_sp, ConvertTimeout(timeout));
 
       if (got_event) {
         if (event_sp) {
           bool keep_going = false;
           if (event_sp->GetType() == eBroadcastBitInterrupt) {
             const bool clear_thread_plans = false;
             const bool use_run_lock = false;
             Halt(clear_thread_plans, use_run_lock);
#endif
             const bool clear_thread_plans = false;
             const bool use_run_lock = false;
             Halt(clear_thread_plans, use_run_lock);
           }
           if (halt_error.Success()) {
             if (log)
               log->PutCString("Process::RunThreadPlan(): Halt succeeded.");
 
-            got_event = listener_sp->WaitForEvent(
-                std::chrono::microseconds(500000), event_sp);
+            got_event =
+                listener_sp->GetEvent(event_sp, std::chrono::milliseconds(500));
 
             if (got_event) {
               stop_state =
                   Process::ProcessEventData::GetStateFromEvent(event_sp.get());
               if (log) {
                 log->Printf("Process::RunThreadPlan(): Stopped with event: %s",
                             StateAsCString(stop_state));
                 if (stop_state == lldb::eStateStopped &&

lldb/trunk/unittests/Core/BroadcasterTest.cpp

 #include <thread>
 
 using namespace lldb;
 using namespace lldb_private;
 
 TEST(BroadcasterTest, BroadcastEvent) {
   EventSP event_sp;
   Broadcaster broadcaster(nullptr, "test-broadcaster");
+  std::chrono::seconds timeout(0);
 
   // Create a listener, sign it up, make sure it recieves an event.
   ListenerSP listener1_sp = Listener::MakeListener("test-listener1");
   const uint32_t event_mask1 = 1;
   EXPECT_EQ(event_mask1,
             listener1_sp->StartListeningForEvents(&broadcaster, event_mask1));
   broadcaster.BroadcastEvent(event_mask1, nullptr);
-  EXPECT_TRUE(listener1_sp->GetNextEvent(event_sp));
+  EXPECT_TRUE(listener1_sp->GetEvent(event_sp, timeout));
   EXPECT_EQ(event_mask1, event_sp->GetType());
 
   {
     // Add one more listener, make sure it works as well.
     ListenerSP listener2_sp = Listener::MakeListener("test-listener2");
     const uint32_t event_mask2 = 1;
     EXPECT_EQ(event_mask2, listener2_sp->StartListeningForEvents(
                                &broadcaster, event_mask1 | event_mask2));
     broadcaster.BroadcastEvent(event_mask2, nullptr);
-    EXPECT_TRUE(listener2_sp->GetNextEvent(event_sp));
+    EXPECT_TRUE(listener2_sp->GetEvent(event_sp, timeout));
     EXPECT_EQ(event_mask2, event_sp->GetType());
 
     // Both listeners should get this event.
     broadcaster.BroadcastEvent(event_mask1, nullptr);
-    EXPECT_TRUE(listener1_sp->GetNextEvent(event_sp));
+    EXPECT_TRUE(listener1_sp->GetEvent(event_sp, timeout));
     EXPECT_EQ(event_mask1, event_sp->GetType());
-    EXPECT_TRUE(listener2_sp->GetNextEvent(event_sp));
+    EXPECT_TRUE(listener2_sp->GetEvent(event_sp, timeout));
     EXPECT_EQ(event_mask2, event_sp->GetType());
   }
 
   // Now again only one listener should be active.
   broadcaster.BroadcastEvent(event_mask1, nullptr);
-  EXPECT_TRUE(listener1_sp->GetNextEvent(event_sp));
+  EXPECT_TRUE(listener1_sp->GetEvent(event_sp, timeout));
   EXPECT_EQ(event_mask1, event_sp->GetType());
 }
 
 TEST(BroadcasterTest, EventTypeHasListeners) {
   EventSP event_sp;
   Broadcaster broadcaster(nullptr, "test-broadcaster");
 
   const uint32_t event_mask = 1;

lldb/trunk/unittests/Core/ListenerTest.cpp

 #include "lldb/Core/Broadcaster.h"
 #include "lldb/Core/Listener.h"
 #include <future>
 #include <thread>
 
 using namespace lldb;
 using namespace lldb_private;
 
-TEST(ListenerTest, GetNextEvent) {
+TEST(ListenerTest, GetEventImmediate) {
   EventSP event_sp;
   Broadcaster broadcaster(nullptr, "test-broadcaster");
 
   // Create a listener, sign it up, make sure it recieves an event.
   ListenerSP listener_sp = Listener::MakeListener("test-listener");
   const uint32_t event_mask = 1;
   ASSERT_EQ(event_mask,
             listener_sp->StartListeningForEvents(&broadcaster, event_mask));
 
+  const std::chrono::seconds timeout(0);
   // Without any events sent, these should return false.
-  EXPECT_FALSE(listener_sp->GetNextEvent(event_sp));
-  EXPECT_FALSE(listener_sp->GetNextEventForBroadcaster(nullptr, event_sp));
-  EXPECT_FALSE(listener_sp->GetNextEventForBroadcaster(&broadcaster, event_sp));
-  EXPECT_FALSE(listener_sp->GetNextEventForBroadcasterWithType(
-      &broadcaster, event_mask, event_sp));
+  EXPECT_FALSE(listener_sp->GetEvent(event_sp, timeout));
+  EXPECT_FALSE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
+  EXPECT_FALSE(
+      listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
+  EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
+      &broadcaster, event_mask, event_sp, timeout));
 
   // Now send events and make sure they get it.
   broadcaster.BroadcastEvent(event_mask, nullptr);
-  EXPECT_TRUE(listener_sp->GetNextEvent(event_sp));
+  EXPECT_TRUE(listener_sp->GetEvent(event_sp, timeout));
 
   broadcaster.BroadcastEvent(event_mask, nullptr);
-  EXPECT_TRUE(listener_sp->GetNextEventForBroadcaster(nullptr, event_sp));
+  EXPECT_TRUE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
 
   broadcaster.BroadcastEvent(event_mask, nullptr);
-  EXPECT_TRUE(listener_sp->GetNextEventForBroadcaster(&broadcaster, event_sp));
+  EXPECT_TRUE(
+      listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
 
   broadcaster.BroadcastEvent(event_mask, nullptr);
-  EXPECT_FALSE(listener_sp->GetNextEventForBroadcasterWithType(
-      &broadcaster, event_mask * 2, event_sp));
-  EXPECT_TRUE(listener_sp->GetNextEventForBroadcasterWithType(
-      &broadcaster, event_mask, event_sp));
+  EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
+      &broadcaster, event_mask * 2, event_sp, timeout));
+  EXPECT_TRUE(listener_sp->GetEventForBroadcasterWithType(
+      &broadcaster, event_mask, event_sp, timeout));
 }
 
-TEST(ListenerTest, WaitForEvent) {
+TEST(ListenerTest, GetEventWait) {
   EventSP event_sp;
   Broadcaster broadcaster(nullptr, "test-broadcaster");
 
   // Create a listener, sign it up, make sure it recieves an event.
   ListenerSP listener_sp = Listener::MakeListener("test-listener");
   const uint32_t event_mask = 1;
   ASSERT_EQ(event_mask,
             listener_sp->StartListeningForEvents(&broadcaster, event_mask));
 
   // Without any events sent, these should make a short wait and return false.
   std::chrono::microseconds timeout(10);
-  EXPECT_FALSE(listener_sp->WaitForEvent(timeout, event_sp));
+  EXPECT_FALSE(listener_sp->GetEvent(event_sp, timeout));
+  EXPECT_FALSE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
   EXPECT_FALSE(
-      listener_sp->WaitForEventForBroadcaster(timeout, nullptr, event_sp));
-  EXPECT_FALSE(
-      listener_sp->WaitForEventForBroadcaster(timeout, &broadcaster, event_sp));
-  EXPECT_FALSE(listener_sp->WaitForEventForBroadcasterWithType(
-      timeout, &broadcaster, event_mask, event_sp));
+      listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
+  EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
+      &broadcaster, event_mask, event_sp, timeout));
 
   // Now send events and make sure they get it.
   broadcaster.BroadcastEvent(event_mask, nullptr);
-  EXPECT_TRUE(listener_sp->WaitForEvent(timeout, event_sp));
+  EXPECT_TRUE(listener_sp->GetEvent(event_sp, timeout));
 
   broadcaster.BroadcastEvent(event_mask, nullptr);
-  EXPECT_TRUE(
-      listener_sp->WaitForEventForBroadcaster(timeout, nullptr, event_sp));
+  EXPECT_TRUE(listener_sp->GetEventForBroadcaster(nullptr, event_sp, timeout));
 
   broadcaster.BroadcastEvent(event_mask, nullptr);
   EXPECT_TRUE(
-      listener_sp->WaitForEventForBroadcaster(timeout, &broadcaster, event_sp));
+      listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, timeout));
 
   broadcaster.BroadcastEvent(event_mask, nullptr);
-  EXPECT_FALSE(listener_sp->WaitForEventForBroadcasterWithType(
-      timeout, &broadcaster, event_mask * 2, event_sp));
-  EXPECT_TRUE(listener_sp->WaitForEventForBroadcasterWithType(
-      timeout, &broadcaster, event_mask, event_sp));
+  EXPECT_FALSE(listener_sp->GetEventForBroadcasterWithType(
+      &broadcaster, event_mask * 2, event_sp, timeout));
+  EXPECT_TRUE(listener_sp->GetEventForBroadcasterWithType(
+      &broadcaster, event_mask, event_sp, timeout));
 
-  timeout = std::chrono::seconds(0);
   auto delayed_broadcast = [&] {
     std::this_thread::sleep_for(std::chrono::milliseconds(10));
     broadcaster.BroadcastEvent(event_mask, nullptr);
   };
 
   // These should do an infinite wait at return the event our asynchronous
   // broadcast sends.
   std::future<void> async_broadcast =
       std::async(std::launch::async, delayed_broadcast);
-  EXPECT_TRUE(listener_sp->WaitForEvent(timeout, event_sp));
+  EXPECT_TRUE(listener_sp->GetEvent(event_sp, llvm::None));
   async_broadcast.get();
 
   async_broadcast = std::async(std::launch::async, delayed_broadcast);
   EXPECT_TRUE(
-      listener_sp->WaitForEventForBroadcaster(timeout, &broadcaster, event_sp));
+      listener_sp->GetEventForBroadcaster(&broadcaster, event_sp, llvm::None));
   async_broadcast.get();
 
   async_broadcast = std::async(std::launch::async, delayed_broadcast);
-  EXPECT_TRUE(listener_sp->WaitForEventForBroadcasterWithType(
-      timeout, &broadcaster, event_mask, event_sp));
+  EXPECT_TRUE(listener_sp->GetEventForBroadcasterWithType(
+      &broadcaster, event_mask, event_sp, llvm::None));
   async_broadcast.get();
 }

lldb/trunk/unittests/Process/gdb-remote/GDBRemoteClientBaseTest.cpp

struct ContinueFixture {
 
   StateType SendCPacket(StringExtractorGDBRemote &response) {
     return client.SendContinuePacketAndWaitForResponse(delegate, LinuxSignals(),
                                                        "c", response);
   }
 
   void WaitForRunEvent() {
     EventSP event_sp;
-    listener_sp->WaitForEventForBroadcasterWithType(
-        std::chrono::microseconds(0), &client,
-        TestClient::eBroadcastBitRunPacketSent, event_sp);
+    listener_sp->GetEventForBroadcasterWithType(
+        &client, TestClient::eBroadcastBitRunPacketSent, event_sp, llvm::None);
   }
 };
 
 ContinueFixture::ContinueFixture()
     : listener_sp(Listener::MakeListener("listener")) {
   Connect(client, server);
   listener_sp->StartListeningForEvents(&client,
                                        TestClient::eBroadcastBitRunPacketSent);