Split the progress manager category bit and setting the external bit for each event

Author: Jlalond

lldb/include/lldb/Core/Progress.h

@@ -21,12 +21,6 @@
 
 namespace lldb_private {
 
-/// Enum to indicate the origin of a progress event, internal or external.
-enum class ProgressOrigin : uint8_t {
-  eLLDBInternal = 0,
-  eExternal = 1,
-};
-
 /// A Progress indicator helper class.
 ///
 /// Any potentially long running sections of code in LLDB should report
@@ -65,6 +59,12 @@ enum class ProgressOrigin : uint8_t {
 
 class Progress {
 public:
+  /// Enum to indicate the origin of a progress event, internal or external.
+  enum class ProgressOrigin : uint8_t {
+    eInternal = 0,
+    eExternal = 1,
+  };
+
   /// Construct a progress object that will report information.
   ///
   /// The constructor will create a unique progress reporting object and
@@ -90,7 +90,7 @@ class Progress {
            std::optional<uint64_t> total = std::nullopt,
            lldb_private::Debugger *debugger = nullptr,
            Timeout<std::nano> minimum_report_time = std::nullopt,
-           ProgressOrigin origin = ProgressOrigin::eLLDBInternal);
+           ProgressOrigin origin = ProgressOrigin::eInternal);
 
   /// Destroy the progress object.
   ///
@@ -125,6 +125,9 @@ class Progress {
     /// The optional debugger ID to report progress to. If this has no value
     /// then all debuggers will receive this event.
     std::optional<lldb::user_id_t> debugger_id;
+
+    /// The origin of the progress event, wheter it is internal or external.
+    Progress::ProgressOrigin origin;
   };
 
 private:
@@ -141,6 +144,9 @@ class Progress {
   /// Data needed by the debugger to broadcast a progress event.
   const ProgressData m_progress_data;
 
+  /// The origin of this progress event.
+  const ProgressOrigin m_origin;
+
   /// How much work ([0...m_total]) that has been completed.
   std::atomic<uint64_t> m_completed = 0;
 
@@ -156,9 +162,6 @@ class Progress {
 
   /// The "completed" value of the last reported event.
   std::optional<uint64_t> m_prev_completed;
-
-  /// The origin of this progress event.
-  ProgressOrigin m_origin;
 };
 
 /// A class used to group progress reports by category. This is done by using a

lldb/include/lldb/lldb-enumerations.h

@@ -195,10 +195,10 @@ enum Format {
                          ///< character arrays that can contain non printable
                          ///< characters
   eFormatAddressInfo,    ///< Describe what an address points to (func + offset
-                         ///< with file/line, symbol + offset, data, etc)
-  eFormatHexFloat,       ///< ISO C99 hex float string
-  eFormatInstruction,    ///< Disassemble an opcode
-  eFormatVoid,           ///< Do not print this
+                      ///< with file/line, symbol + offset, data, etc)
+  eFormatHexFloat,    ///< ISO C99 hex float string
+  eFormatInstruction, ///< Disassemble an opcode
+  eFormatVoid,        ///< Do not print this
   eFormatUnicode8,
   kNumFormats
 };
@@ -302,7 +302,7 @@ enum ConnectionStatus {
   eConnectionStatusNoConnection,   ///< No connection
   eConnectionStatusLostConnection, ///< Lost connection while connected to a
                                    ///< valid connection
-  eConnectionStatusInterrupted     ///< Interrupted read
+  eConnectionStatusInterrupted ///< Interrupted read
 };
 
 enum ErrorType {
@@ -1094,7 +1094,7 @@ enum PathType {
   ePathTypeGlobalLLDBTempSystemDir, ///< The LLDB temp directory for this
                                     ///< system, NOT cleaned up on a process
                                     ///< exit.
-  ePathTypeClangDir                 ///< Find path to Clang builtin headers
+  ePathTypeClangDir ///< Find path to Clang builtin headers
 };
 
 /// Kind of member function.
@@ -1357,7 +1357,8 @@ enum DebuggerBroadcastBit {
   eBroadcastBitError = (1 << 2),
   eBroadcastSymbolChange = (1 << 3),
   eBroadcastBitProgressCategory = (1 << 4),
-  eBroadcastBitExternalProgressCategory = (1 << 5),
+  eBroadcastBitExternalProgress = (1 << 5),
+  eBroadcastBitExternalProgressCategory = (1 << 6),
 };
 
 /// Used for expressing severity in logs and diagnostics.

lldb/source/Core/Progress.cpp

@@ -29,17 +29,19 @@ Progress::Progress(std::string title, std::string details,
                    std::optional<uint64_t> total,
                    lldb_private::Debugger *debugger,
                    Timeout<std::nano> minimum_report_time,
-                   ProgressOrigin origin)
+                   Progress::ProgressOrigin origin)
     : m_total(total.value_or(Progress::kNonDeterministicTotal)),
       m_minimum_report_time(minimum_report_time),
       m_progress_data{title, ++g_id,
                       debugger ? std::optional<user_id_t>(debugger->GetID())
-                               : std::nullopt},
+                               : std::nullopt,
+                      origin},
+      m_origin(origin),
       m_last_report_time_ns(
           std::chrono::nanoseconds(
               std::chrono::steady_clock::now().time_since_epoch())
               .count()),
-      m_details(std::move(details)), m_origin(origin) {
+      m_details(std::move(details)) {
   std::lock_guard<std::mutex> guard(m_mutex);
   ReportProgress();
 
@@ -108,10 +110,9 @@ void Progress::ReportProgress() {
     return; // An overflow in the m_completed counter. Just ignore these events.
 
   // Change the category bit if we're an internal or external progress.
-  uint32_t progress_category_bit =
-      m_origin == ProgressOrigin::eExternal
-          ? lldb::eBroadcastBitExternalProgressCategory
-          : lldb::eBroadcastBitProgressCategory;
+  uint32_t progress_category_bit = m_origin == ProgressOrigin::eExternal
+                                       ? lldb::eBroadcastBitProgress
+                                       : lldb::eBroadcastBitExternalProgress;
 
   Debugger::ReportProgress(m_progress_data.progress_id, m_progress_data.title,
                            m_details, completed, m_total,
@@ -208,10 +209,13 @@ void ProgressManager::ReportProgress(
   // broadcasting to it since that bit doesn't need that information.
   const uint64_t completed =
       (type == EventType::Begin) ? 0 : Progress::kNonDeterministicTotal;
+  const uint32_t progress_category_bit =
+      progress_data.origin == Progress::ProgressOrigin::eExternal
+          ? lldb::eBroadcastBitExternalProgressCategory
+          : lldb::eBroadcastBitProgressCategory;
   Debugger::ReportProgress(progress_data.progress_id, progress_data.title, "",
                            completed, Progress::kNonDeterministicTotal,
-                           progress_data.debugger_id,
-                           lldb::eBroadcastBitProgressCategory);
+                           progress_data.debugger_id, progress_category_bit);
 }
 
 void ProgressManager::Expire(llvm::StringRef key) {