[lldb] Move ProgressEventData out of debugger and into its own file (NFC)

[JDevlieghere]

Summary

Move ProgressEventData out of debugger and into its own file. This is in preparation of adding a new type of event data for warnings/errors.

lldb/include/lldb/Core/Debugger.h

 
 namespace lldb_private {
 class Address;
 class CommandInterpreter;
 class Process;
 class Stream;
 class SymbolContext;
 class Target;
+class ProgressEventData;
 
 namespace repro {
 class DataRecorder;
 }
 
 /// \class Debugger Debugger.h "lldb/Core/Debugger.h"
 /// A class to manage flag bits.
 ///
public:
   };
 
   static ConstString GetStaticBroadcasterClass();
 
   /// Get the public broadcaster for this debugger.
   Broadcaster &GetBroadcaster() { return m_broadcaster; }
   const Broadcaster &GetBroadcaster() const { return m_broadcaster; }
 
-  class ProgressEventData : public EventData {
-
-  public:
-    ProgressEventData(uint64_t progress_id, const std::string &message,
-                      uint64_t completed, uint64_t total,
-                      bool debugger_specific)
-        : m_message(message), m_id(progress_id), m_completed(completed),
-          m_total(total), m_debugger_specific(debugger_specific) {}
-
-    static ConstString GetFlavorString();
-
-    ConstString GetFlavor() const override;
-
-    void Dump(Stream *s) const override;
-
-    static const ProgressEventData *
-    GetEventDataFromEvent(const Event *event_ptr);
-    uint64_t GetID() const { return m_id; }
-    uint64_t GetCompleted() const { return m_completed; }
-    uint64_t GetTotal() const { return m_total; }
-    const std::string &GetMessage() const { return m_message; }
-    bool IsDebuggerSpecific() const { return m_debugger_specific; }
-
-  private:
-    std::string m_message;
-    const uint64_t m_id;
-    uint64_t m_completed;
-    const uint64_t m_total;
-    const bool m_debugger_specific;
-    ProgressEventData(const ProgressEventData &) = delete;
-    const ProgressEventData &operator=(const ProgressEventData &) = delete;
-  };
-
   ~Debugger() override;
 
   static lldb::DebuggerSP
   CreateInstance(lldb::LogOutputCallback log_callback = nullptr,
                  void *baton = nullptr);
 
   static lldb::TargetSP FindTargetWithProcessID(lldb::pid_t pid);
 
protected:
   ///   If this optional parameter has a value, it indicates the unique
   ///   debugger identifier that this progress should be delivered to. If this
   ///   optional parameter does not have a value, the progress will be
   ///   delivered to all debuggers.
   static void ReportProgress(uint64_t progress_id, const std::string &message,
                              uint64_t completed, uint64_t total,
                              llvm::Optional<lldb::user_id_t> debugger_id);
 
-  void PrintProgress(const Debugger::ProgressEventData &data);
+  void PrintProgress(const ProgressEventData &data);
 
   bool StartEventHandlerThread();
 
   void StopEventHandlerThread();
 
   void PushIOHandler(const lldb::IOHandlerSP &reader_sp,
                      bool cancel_top_handler = true);
 

lldb/include/lldb/Core/DebuggerEvents.h

+//===-- DebuggerEvents.h ----------------------------------------*- C++ -*-===//
+//
+// 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/ConstString.h"
+#include "lldb/Utility/Event.h"
+
+#include <string>
+
+#ifndef LLDB_CORE_DEBUGGER_EVENTS_H
+#define LLDB_CORE_DEBUGGER_EVENTS_H
+
+namespace lldb_private {
+class Stream;
+
+class ProgressEventData : public EventData {
+public:
+  ProgressEventData(uint64_t progress_id, const std::string &message,
+                    uint64_t completed, uint64_t total, bool debugger_specific)
+      : m_message(message), m_id(progress_id), m_completed(completed),
+        m_total(total), m_debugger_specific(debugger_specific) {}
+
+  static ConstString GetFlavorString();
+
+  ConstString GetFlavor() const override;
+
+  void Dump(Stream *s) const override;
+
+  static const ProgressEventData *GetEventDataFromEvent(const Event *event_ptr);
+  uint64_t GetID() const { return m_id; }
+  uint64_t GetCompleted() const { return m_completed; }
+  uint64_t GetTotal() const { return m_total; }
+  const std::string &GetMessage() const { return m_message; }
+  bool IsDebuggerSpecific() const { return m_debugger_specific; }
+
+private:
+  std::string m_message;
+  const uint64_t m_id;
+  uint64_t m_completed;
+  const uint64_t m_total;
+  const bool m_debugger_specific;
+  ProgressEventData(const ProgressEventData &) = delete;
+  const ProgressEventData &operator=(const ProgressEventData &) = delete;
+};
+} // namespace lldb_private
+
+#endif // LLDB_CORE_DEBUGGER_EVENTS_H

lldb/source/API/SBDebugger.cpp

 #include "lldb/API/SBTypeCategory.h"
 #include "lldb/API/SBTypeFilter.h"
 #include "lldb/API/SBTypeFormat.h"
 #include "lldb/API/SBTypeNameSpecifier.h"
 #include "lldb/API/SBTypeSummary.h"
 #include "lldb/API/SBTypeSynthetic.h"
 
 #include "lldb/Core/Debugger.h"
+#include "lldb/Core/DebuggerEvents.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Progress.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Host/XML.h"
 #include "lldb/Initialization/SystemLifetimeManager.h"

 }
 
 const char *SBDebugger::GetProgressFromEvent(const lldb::SBEvent &event,
                                              uint64_t &progress_id,
                                              uint64_t &completed,
                                              uint64_t &total,
                                              bool &is_debugger_specific) {
   LLDB_INSTRUMENT_VA(event);
-  const Debugger::ProgressEventData *progress_data =
-      Debugger::ProgressEventData::GetEventDataFromEvent(event.get());
+  const ProgressEventData *progress_data =
+      ProgressEventData::GetEventDataFromEvent(event.get());
   if (progress_data == nullptr)
     return nullptr;
   progress_id = progress_data->GetID();
   completed = progress_data->GetCompleted();
   total = progress_data->GetTotal();
   is_debugger_specific = progress_data->IsDebuggerSpecific();
   return progress_data->GetMessage().c_str();
 }

lldb/source/Core/CMakeLists.txt

 add_lldb_library(lldbCore
   Address.cpp
   AddressRange.cpp
   AddressResolver.cpp
   AddressResolverFileLine.cpp
   Communication.cpp
   DataFileCache.cpp
   Debugger.cpp
+  DebuggerEvents.cpp
   Declaration.cpp
   Disassembler.cpp
   DumpDataExtractor.cpp
   DumpRegisterValue.cpp
   DynamicLoader.cpp
   EmulateInstruction.cpp
   FileLineResolver.cpp
   FileSpecList.cpp

lldb/source/Core/Debugger.cpp

 //===-- Debugger.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/Core/Debugger.h"
 
 #include "lldb/Breakpoint/Breakpoint.h"
+#include "lldb/Core/DebuggerEvents.h"
 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/Mangled.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamAsynchronousIO.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/Expression/REPL.h"
void Debugger::SetLoggingCallback(lldb::LogOutputCallback log_callback,
                                   void *baton) {
   // For simplicity's sake, I am not going to deal with how to close down any
   // open logging streams, I just redirect everything from here on out to the
   // callback.
   m_log_callback_stream_sp =
       std::make_shared<StreamCallback>(log_callback, baton);
 }
 
-ConstString Debugger::ProgressEventData::GetFlavorString() {
-  static ConstString g_flavor("Debugger::ProgressEventData");
-  return g_flavor;
-}
-
-ConstString Debugger::ProgressEventData::GetFlavor() const {
-  return Debugger::ProgressEventData::GetFlavorString();
-}
-
-void Debugger::ProgressEventData::Dump(Stream *s) const {
-  s->Printf(" id = %" PRIu64 ", message = \"%s\"", m_id, m_message.c_str());
-  if (m_completed == 0 || m_completed == m_total)
-    s->Printf(", type = %s", m_completed == 0 ? "start" : "end");
-  else
-    s->PutCString(", type = update");
-  // If m_total is UINT64_MAX, there is no progress to report, just "start"
-  // and "end". If it isn't we will show the completed and total amounts.
-  if (m_total != UINT64_MAX)
-    s->Printf(", progress = %" PRIu64 " of %" PRIu64, m_completed, m_total);
-}
-
-const Debugger::ProgressEventData *
-Debugger::ProgressEventData::GetEventDataFromEvent(const Event *event_ptr) {
-  if (event_ptr)
-    if (const EventData *event_data = event_ptr->GetData())
-      if (event_data->GetFlavor() == ProgressEventData::GetFlavorString())
-        return static_cast<const ProgressEventData *>(event_ptr->GetData());
-  return nullptr;
-}
-
 static void PrivateReportProgress(Debugger &debugger, uint64_t progress_id,
                                   const std::string &message,
                                   uint64_t completed, uint64_t total,
                                   bool is_debugger_specific) {
   // Only deliver progress events if we have any progress listeners.
   const uint32_t event_type = Debugger::eBroadcastBitProgress;
   if (!debugger.GetBroadcaster().EventTypeHasListeners(event_type))
     return;
-  EventSP event_sp(new Event(event_type, new Debugger::ProgressEventData(
-                                             progress_id, message, completed,
-                                             total, is_debugger_specific)));
+  EventSP event_sp(new Event(
+      event_type, new ProgressEventData(progress_id, message, completed, total,
+                                        is_debugger_specific)));
   debugger.GetBroadcaster().BroadcastEvent(event_sp);
 }
 
 void Debugger::ReportProgress(uint64_t progress_id, const std::string &message,
                               uint64_t completed, uint64_t total,
                               llvm::Optional<lldb::user_id_t> debugger_id) {
   // Check if this progress is for a specific debugger.
   if (debugger_id.hasValue()) {

 
 lldb::thread_result_t Debugger::IOHandlerThread() {
   RunIOHandlers();
   StopEventHandlerThread();
   return {};
 }
 
 void Debugger::HandleProgressEvent(const lldb::EventSP &event_sp) {
-  auto *data =
-      Debugger::ProgressEventData::GetEventDataFromEvent(event_sp.get());
+  auto *data = ProgressEventData::GetEventDataFromEvent(event_sp.get());
   if (!data)
     return;
 
   // Do some bookkeeping for the current event, regardless of whether we're
   // going to show the progress.
   const uint64_t id = data->GetID();
   if (m_current_event_id) {
     if (id != *m_current_event_id)

lldb/source/Core/DebuggerEvents.cpp

+//===-- DebuggerEvents.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/Core/DebuggerEvents.h"
+
+using namespace lldb_private;
+
+ConstString ProgressEventData::GetFlavorString() {
+  static ConstString g_flavor("ProgressEventData");
+  return g_flavor;
+}
+
+ConstString ProgressEventData::GetFlavor() const {
+  return ProgressEventData::GetFlavorString();
+}
+
+void ProgressEventData::Dump(Stream *s) const {
+  s->Printf(" id = %" PRIu64 ", message = \"%s\"", m_id, m_message.c_str());
+  if (m_completed == 0 || m_completed == m_total)
+    s->Printf(", type = %s", m_completed == 0 ? "start" : "end");
+  else
+    s->PutCString(", type = update");
+  // If m_total is UINT64_MAX, there is no progress to report, just "start"
+  // and "end". If it isn't we will show the completed and total amounts.
+  if (m_total != UINT64_MAX)
+    s->Printf(", progress = %" PRIu64 " of %" PRIu64, m_completed, m_total);
+}
+
+const ProgressEventData *
+ProgressEventData::GetEventDataFromEvent(const Event *event_ptr) {
+  if (event_ptr)
+    if (const EventData *event_data = event_ptr->GetData())
+      if (event_data->GetFlavor() == ProgressEventData::GetFlavorString())
+        return static_cast<const ProgressEventData *>(event_ptr->GetData());
+  return nullptr;
+}