[gdb-remote] Move broadcasting logic down to GDBRemoteClientBase

[mgorny]

Summary

Move the broadcasting support from GDBRemoteCommunication
to GDBRemoteClientBase since this is where it is actually used. Remove
GDBRemoteCommunication and subclass constructor arguments left over
after Communication cleanup.

Sponsored by: The FreeBSD Foundation

[labath]

cool.

lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationTest.cpp

20

I think you can just delete this altogether.

lldb/source/Plugins/Process/gdb-remote/GDBRemoteClientBase.h

 
 #include "GDBRemoteCommunication.h"
 
 #include <condition_variable>
 
 namespace lldb_private {
 namespace process_gdb_remote {
 
-class GDBRemoteClientBase : public GDBRemoteCommunication {
+class GDBRemoteClientBase : public GDBRemoteCommunication, public Broadcaster {
 public:
+  enum {
+    eBroadcastBitRunPacketSent = (1u << 0),
+  };
+
   struct ContinueDelegate {
     virtual ~ContinueDelegate();
     virtual void HandleAsyncStdout(llvm::StringRef out) = 0;
     virtual void HandleAsyncMisc(llvm::StringRef data) = 0;
     virtual void HandleStopReply() = 0;
 
     /// Process asynchronously-received structured data.
     ///
     /// \param[in] data
     ///   The complete data packet, expected to start with JSON-async.
     virtual void HandleAsyncStructuredDataPacket(llvm::StringRef data) = 0;
   };
 
-  GDBRemoteClientBase(const char *comm_name, const char *listener_name);
+  GDBRemoteClientBase(const char *comm_name);
 
   bool SendAsyncSignal(int signo, std::chrono::seconds interrupt_timeout);
 
   bool Interrupt(std::chrono::seconds interrupt_timeout);
 
   lldb::StateType SendContinuePacketAndWaitForResponse(
       ContinueDelegate &delegate, const UnixSignals &signals,
       llvm::StringRef payload, std::chrono::seconds interrupt_timeout,

lldb/source/Plugins/Process/gdb-remote/GDBRemoteClientBase.cpp

 static const seconds kWakeupInterval(5);
 
 /////////////////////////
 // GDBRemoteClientBase //
 /////////////////////////
 
 GDBRemoteClientBase::ContinueDelegate::~ContinueDelegate() = default;
 
-GDBRemoteClientBase::GDBRemoteClientBase(const char *comm_name,
-                                         const char *listener_name)
-    : GDBRemoteCommunication(comm_name, listener_name), m_async_count(0),
-      m_is_running(false), m_should_stop(false) {}
+GDBRemoteClientBase::GDBRemoteClientBase(const char *comm_name)
+    : GDBRemoteCommunication(), Broadcaster(nullptr, comm_name),
+      m_async_count(0), m_is_running(false), m_should_stop(false) {}
 
 StateType GDBRemoteClientBase::SendContinuePacketAndWaitForResponse(
     ContinueDelegate &delegate, const UnixSignals &signals,
     llvm::StringRef payload, std::chrono::seconds interrupt_timeout,
     StringExtractorGDBRemote &response) {
   Log *log = GetLog(GDBRLog::Process);
   response.Clear();
 

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h

 enum GDBErrno {
 #define HANDLE_ERRNO(name, value) GDB_##name = value,
 #include "Plugins/Process/gdb-remote/GDBRemoteErrno.def"
   GDB_EUNKNOWN = 9999
 };
 
 class ProcessGDBRemote;
 
-class GDBRemoteCommunication : public Communication, public Broadcaster {
+class GDBRemoteCommunication : public Communication {
 public:
-  enum {
-    eBroadcastBitRunPacketSent = (1u << 0),
-  };
-
   enum class PacketType { Invalid = 0, Standard, Notify };
 
   enum class PacketResult {
     Success = 0,        // Success
     ErrorSendFailed,    // Status sending the packet
     ErrorSendAck,       // Didn't get an ack back after sending a packet
     ErrorReplyFailed,   // Status getting the reply
     ErrorReplyTimeout,  // Timed out waiting for reply
private:
     GDBRemoteCommunication &m_gdb_comm;
     std::chrono::seconds m_saved_timeout;
     // Don't ever reduce the timeout for a packet, only increase it. If the
     // requested timeout if less than the current timeout, we don't set it
     // and won't need to restore it.
     bool m_timeout_modified;
   };
 
-  GDBRemoteCommunication(const char *comm_name, const char *listener_name);
+  GDBRemoteCommunication();
 
   ~GDBRemoteCommunication() override;
 
   PacketResult GetAck();
 
   size_t SendAck();
 
   size_t SendNack();

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

 #include <zlib.h>
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_gdb_remote;
 
 // GDBRemoteCommunication constructor
-GDBRemoteCommunication::GDBRemoteCommunication(const char *comm_name,
-                                               const char *listener_name)
-    : Communication(), Broadcaster(nullptr, comm_name),
+GDBRemoteCommunication::GDBRemoteCommunication()
+    : Communication(),
 #ifdef LLDB_CONFIGURATION_DEBUG
       m_packet_timeout(1000),
 #else
       m_packet_timeout(1),
 #endif
       m_echo_number(0), m_supports_qEcho(eLazyBoolCalculate), m_history(512),
       m_send_acks(true), m_is_platform(false),
       m_compression_type(CompressionType::None), m_listen_url() {

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

llvm::raw_ostream &process_gdb_remote::operator<<(llvm::raw_ostream &os,
                                                   const QOffsets &offsets) {
   return os << llvm::formatv(
              "QOffsets({0}, [{1:@[x]}])", offsets.segments,
              llvm::make_range(offsets.offsets.begin(), offsets.offsets.end()));
 }
 
 // GDBRemoteCommunicationClient constructor
 GDBRemoteCommunicationClient::GDBRemoteCommunicationClient()
-    : GDBRemoteClientBase("gdb-remote.client", "gdb-remote.client.rx_packet"),
+    : GDBRemoteClientBase("gdb-remote.client"),
 
       m_supports_qProcessInfoPID(true), m_supports_qfProcessInfo(true),
       m_supports_qUserName(true), m_supports_qGroupName(true),
       m_supports_qThreadStopInfo(true), m_supports_z0(true),
       m_supports_z1(true), m_supports_z2(true), m_supports_z3(true),
       m_supports_z4(true), m_supports_QEnvironment(true),
       m_supports_QEnvironmentHexEncoded(true), m_supports_qSymbol(true),
       m_qSymbol_requests_done(false), m_supports_qModuleInfo(true),

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.h

 class ProcessGDBRemote;
 
 class GDBRemoteCommunicationServer : public GDBRemoteCommunication {
 public:
   using PacketHandler =
       std::function<PacketResult(StringExtractorGDBRemote &packet,
                                  Status &error, bool &interrupt, bool &quit)>;
 
-  GDBRemoteCommunicationServer(const char *comm_name,
-                               const char *listener_name);
+  GDBRemoteCommunicationServer();
 
   ~GDBRemoteCommunicationServer() override;
 
   void
   RegisterPacketHandler(StringExtractorGDBRemote::ServerPacketType packet_type,
                         PacketHandler handler);
 
   PacketResult GetPacketAndSendResponse(Timeout<std::micro> timeout,

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.cpp

 #include "llvm/Support/JSON.h"
 #include <cstring>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_gdb_remote;
 using namespace llvm;
 
-GDBRemoteCommunicationServer::GDBRemoteCommunicationServer(
-    const char *comm_name, const char *listener_name)
-    : GDBRemoteCommunication(comm_name, listener_name), m_exit_now(false) {
+GDBRemoteCommunicationServer::GDBRemoteCommunicationServer()
+    : GDBRemoteCommunication(), m_exit_now(false) {
   RegisterPacketHandler(
       StringExtractorGDBRemote::eServerPacketType_QEnableErrorStrings,
       [this](StringExtractorGDBRemote packet, Status &error, bool &interrupt,
              bool &quit) { return this->Handle_QErrorStringEnable(packet); });
 }
 
 GDBRemoteCommunicationServer::~GDBRemoteCommunicationServer() = default;
 

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.h

 
 namespace lldb_private {
 namespace process_gdb_remote {
 
 class ProcessGDBRemote;
 
 class GDBRemoteCommunicationServerCommon : public GDBRemoteCommunicationServer {
 public:
-  GDBRemoteCommunicationServerCommon(const char *comm_name,
-                                     const char *listener_name);
+  GDBRemoteCommunicationServerCommon();
 
   ~GDBRemoteCommunicationServerCommon() override;
 
 protected:
   ProcessLaunchInfo m_process_launch_info;
   Status m_process_launch_error;
   ProcessInstanceInfoList m_proc_infos;
   uint32_t m_proc_infos_index;

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

 
 #ifdef __ANDROID__
 const static uint32_t g_default_packet_timeout_sec = 20; // seconds
 #else
 const static uint32_t g_default_packet_timeout_sec = 0; // not specified
 #endif
 
 // GDBRemoteCommunicationServerCommon constructor
-GDBRemoteCommunicationServerCommon::GDBRemoteCommunicationServerCommon(
-    const char *comm_name, const char *listener_name)
-    : GDBRemoteCommunicationServer(comm_name, listener_name),
-      m_process_launch_info(), m_process_launch_error(), m_proc_infos(),
-      m_proc_infos_index(0) {
+GDBRemoteCommunicationServerCommon::GDBRemoteCommunicationServerCommon()
+    : GDBRemoteCommunicationServer(), m_process_launch_info(),
+      m_process_launch_error(), m_proc_infos(), m_proc_infos_index(0) {
   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_A,
                                 &GDBRemoteCommunicationServerCommon::Handle_A);
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_QEnvironment,
       &GDBRemoteCommunicationServerCommon::Handle_QEnvironment);
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_QEnvironmentHexEncoded,
       &GDBRemoteCommunicationServerCommon::Handle_QEnvironmentHexEncoded);

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

enum GDBRemoteServerError {
   eErrorResume,
   eErrorExitStatus
 };
 }
 
 // GDBRemoteCommunicationServerLLGS constructor
 GDBRemoteCommunicationServerLLGS::GDBRemoteCommunicationServerLLGS(
     MainLoop &mainloop, const NativeProcessProtocol::Factory &process_factory)
-    : GDBRemoteCommunicationServerCommon("gdb-remote.server",
-                                         "gdb-remote.server.rx_packet"),
-      m_mainloop(mainloop), m_process_factory(process_factory),
-      m_current_process(nullptr), m_continue_process(nullptr),
-      m_stdio_communication() {
+    : GDBRemoteCommunicationServerCommon(), m_mainloop(mainloop),
+      m_process_factory(process_factory), m_current_process(nullptr),
+      m_continue_process(nullptr), m_stdio_communication() {
   RegisterPacketHandlers();
 }
 
 void GDBRemoteCommunicationServerLLGS::RegisterPacketHandlers() {
   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_C,
                                 &GDBRemoteCommunicationServerLLGS::Handle_C);
   RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_c,
                                 &GDBRemoteCommunicationServerLLGS::Handle_c);

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerPlatform.cpp

 
 bool GDBRemoteCommunicationServerPlatform::PortMap::empty() const {
   return m_port_map.empty();
 }
 
 // GDBRemoteCommunicationServerPlatform constructor
 GDBRemoteCommunicationServerPlatform::GDBRemoteCommunicationServerPlatform(
     const Socket::SocketProtocol socket_protocol, const char *socket_scheme)
-    : GDBRemoteCommunicationServerCommon("gdb-remote.server",
-                                         "gdb-remote.server.rx_packet"),
+    : GDBRemoteCommunicationServerCommon(),
       m_socket_protocol(socket_protocol), m_socket_scheme(socket_scheme),
       m_spawned_pids_mutex(), m_port_map(), m_port_offset(0) {
   m_pending_gdb_server.pid = LLDB_INVALID_PROCESS_ID;
   m_pending_gdb_server.port = 0;
 
   RegisterMemberFunctionHandler(
       StringExtractorGDBRemote::eServerPacketType_qC,
       &GDBRemoteCommunicationServerPlatform::Handle_qC);

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

 Status ProcessGDBRemote::DoResume() {
   Status error;
   Log *log = GetLog(GDBRLog::Process);
   LLDB_LOGF(log, "ProcessGDBRemote::Resume()");
 
   ListenerSP listener_sp(
       Listener::MakeListener("gdb-remote.resume-packet-sent"));
   if (listener_sp->StartListeningForEvents(
-          &m_gdb_comm, GDBRemoteCommunication::eBroadcastBitRunPacketSent)) {
+          &m_gdb_comm, GDBRemoteClientBase::eBroadcastBitRunPacketSent)) {
     listener_sp->StartListeningForEvents(
         &m_async_broadcaster,
         ProcessGDBRemote::eBroadcastBitAsyncThreadDidExit);
 
     const size_t num_threads = GetThreadList().GetSize();
 
     StreamString continue_packet;
     bool continue_packet_error = false;

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

struct MockDelegate : public GDBRemoteClientBase::ContinueDelegate {
   void HandleStopReply() override { ++stop_reply_called; }
 
   void HandleAsyncStructuredDataPacket(llvm::StringRef data) override {
     structured_data_packets.push_back(std::string(data));
   }
 };
 
 struct TestClient : public GDBRemoteClientBase {
-  TestClient() : GDBRemoteClientBase("test.client", "test.client.listener") {
+  TestClient() : GDBRemoteClientBase("test.client") {
     m_send_acks = false;
   }
 };
 
 class GDBRemoteClientBaseTest : public GDBRemoteTest {
 public:
   void SetUp() override {
     ASSERT_THAT_ERROR(GDBRemoteCommunication::ConnectLocally(client, server),

lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationTest.cpp

 using namespace lldb_private;
 using namespace lldb;
 typedef GDBRemoteCommunication::PacketResult PacketResult;
 
 namespace {
 
 class TestClient : public GDBRemoteCommunication {
 public:
-  TestClient()
-      : GDBRemoteCommunication("test.client", "test.client.listener") {}
+  TestClient() : GDBRemoteCommunication() {}
 
   PacketResult ReadPacket(StringExtractorGDBRemote &response) {
     return GDBRemoteCommunication::ReadPacket(response, std::chrono::seconds(1),
                                               /*sync_on_timeout*/ false);
   }
 };
 
 class GDBRemoteCommunicationTest : public GDBRemoteTest {

lldb/unittests/Process/gdb-remote/GDBRemoteTestUtils.h

public:
 
   lldb::IOObjectSP GetReadObject() { return lldb::IOObjectSP(); }
 
   std::vector<std::string> *m_packets;
 };
 
 class MockServer : public GDBRemoteCommunicationServer {
 public:
-  MockServer()
-      : GDBRemoteCommunicationServer("mock-server", "mock-server.listener") {
+  MockServer() : GDBRemoteCommunicationServer() {
     m_send_acks = false;
     m_send_error_strings = true;
   }
 
   PacketResult SendPacket(llvm::StringRef payload) {
     return GDBRemoteCommunicationServer::SendPacketNoLock(payload);
   }