[lldb] [gdb-remote] Abstract sending ^c packet into SendCtrlC() method

[mgorny]

Summary

Abstract sending ^c packet into a dedicated
GDBRemoteClientBase::SendCtrlC() method. This makes it possible to avoid
exposing the complete Write() method in the API.

Sponsored by: The FreeBSD Foundation

[emaste]

Maybe we want to call it SendInterrupt? Looks fine to me as a minor tidy-up either way.

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

public:
   // Wrappers for GDBRemoteCommunication API.
   PacketResult ReadPacket(StringExtractorGDBRemote &response,
                           Timeout<std::micro> timeout, bool sync_on_timeout);
 
   PacketResult SendPacketNoLock(llvm::StringRef payload);
 
   size_t SendAck();
 
-  size_t Write(const void *src, size_t src_len, lldb::ConnectionStatus &status,
-               Status *error_ptr);
+  bool SendCtrlC();
 
   bool IsConnected() const;
 
   lldb::ConnectionStatus Disconnect(Status *error_ptr = nullptr);
 
   GDBRemoteCommunication &GetCommunication() {
     return m_comm;
   }

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

if (m_comm.m_is_running && m_interrupt_timeout == std::chrono::seconds(0))
     return; // We were asked to avoid interrupting the sender. Lock is not
             // acquired.
 
   ++m_comm.m_async_count;
   if (m_comm.m_is_running) {
     if (m_comm.m_async_count == 1) {
       // The sender has sent the continue packet and we are the first async
       // packet. Let's interrupt it.
-      const char ctrl_c = '\x03';
-      ConnectionStatus status = eConnectionStatusSuccess;
-      size_t bytes_written = m_comm.Write(&ctrl_c, 1, status, nullptr);
-      if (bytes_written == 0) {
+      if (!m_comm.SendCtrlC()) {
         --m_comm.m_async_count;
         LLDB_LOGF(log, "GDBRemoteClientBase::Lock::Lock failed to send "
                        "interrupt packet");
         return;
       }
       m_comm.m_interrupt_endpoint = steady_clock::now() + m_interrupt_timeout;
       if (log)
         log->PutCString("GDBRemoteClientBase::Lock::Lock sent packet: \\x03");

 
 GDBRemoteClientBase::PacketResult
 GDBRemoteClientBase::SendPacketNoLock(llvm::StringRef payload) {
   return m_comm.SendPacketNoLock(payload);
 }
 
 size_t GDBRemoteClientBase::SendAck() { return m_comm.SendAck(); }
 
-size_t GDBRemoteClientBase::Write(const void *src, size_t src_len,
-                                  ConnectionStatus &status, Status *error_ptr) {
-  return m_comm.Write(src, src_len, status, error_ptr);
+bool GDBRemoteClientBase::SendCtrlC() {
+  const char ctrl_c = '\x03';
+  ConnectionStatus status = eConnectionStatusSuccess;
+  size_t bytes_written = m_comm.Write(&ctrl_c, 1, status, nullptr);
+  return bytes_written != 0;
 }
 
 bool GDBRemoteClientBase::IsConnected() const { return m_comm.IsConnected(); }
 
 ConnectionStatus GDBRemoteClientBase::Disconnect(Status *error_ptr) {
   return m_comm.Disconnect(error_ptr);
 }