DAP: Change unique_ptr to QObject parenting

Change-Id: I47f5db1823e69829294fb9f551a2edcb980d86dc
Reviewed-by: hjk <hjk@qt.io>

src/plugins/debugger/dap/cmakedapengine.cpp

@@ -29,8 +29,9 @@ namespace Debugger::Internal {
 class LocalSocketDataProvider : public IDataProvider
 {
 public:
-    LocalSocketDataProvider(const QString &socketName)
+    LocalSocketDataProvider(const QString &socketName, QObject *parent = nullptr)
-        : m_socketName(socketName)
+        : IDataProvider(parent)
+        , m_socketName(socketName)
     {
         connect(&m_socket, &QLocalSocket::connected, this, &IDataProvider::started);
         connect(&m_socket, &QLocalSocket::disconnected, this, &IDataProvider::done);
@@ -74,8 +75,8 @@ private:
 class CMakeDapClient : public DapClient
 {
 public:
-    CMakeDapClient(std::unique_ptr<IDataProvider> provider)
+    CMakeDapClient(IDataProvider *provider, QObject *parent = nullptr)
-        : DapClient(std::move(provider))
+        : DapClient(provider, parent)
     {}
 
     void sendInitialize()
@@ -102,14 +103,15 @@ void CMakeDapEngine::setupEngine()
     qCDebug(dapEngineLog) << "build system name"
                           << ProjectExplorer::ProjectTree::currentBuildSystem()->name();
 
-    std::unique_ptr<IDataProvider> dataProvider;
+    IDataProvider *dataProvider;
     if (TemporaryDirectory::masterDirectoryFilePath().osType() == Utils::OsType::OsTypeWindows) {
-        dataProvider = std::make_unique<LocalSocketDataProvider>("\\\\.\\pipe\\cmake-dap");
+        dataProvider = new LocalSocketDataProvider("\\\\.\\pipe\\cmake-dap", this);
     } else {
-        dataProvider = std::make_unique<LocalSocketDataProvider>(
+        dataProvider = new LocalSocketDataProvider(TemporaryDirectory::masterDirectoryPath()
-            TemporaryDirectory::masterDirectoryPath() + "/cmake-dap.sock");
+                                                       + "/cmake-dap.sock",
+                                                   this);
     }
-    m_dapClient = std::make_unique<CMakeDapClient>(std::move(dataProvider));
+    m_dapClient = new CMakeDapClient(dataProvider, this);
     connectDataGeneratorSignals();
 
     connect(ProjectExplorer::ProjectTree::currentBuildSystem(),

src/plugins/debugger/dap/dapclient.cpp

@@ -17,20 +17,21 @@ static Q_LOGGING_CATEGORY(dapEngineLog, "qtc.dbg.dapengine", QtWarningMsg);
 
 namespace Debugger::Internal {
 
-DapClient::DapClient(std::unique_ptr<IDataProvider> dataProvider)
+DapClient::DapClient(IDataProvider *dataProvider, QObject *parent)
-    : m_dataProvider(std::move(dataProvider))
+    : QObject(parent)
+    , m_dataProvider(dataProvider)
 {
-    connect(m_dataProvider.get(),
+    connect(m_dataProvider,
             &IDataProvider::readyReadStandardOutput,
             this,
             &DapClient::readOutput);
-    connect(m_dataProvider.get(),
+    connect(m_dataProvider,
             &IDataProvider::readyReadStandardError,
             this,
             &DapClient::readyReadStandardError);
 
-    connect(m_dataProvider.get(), &IDataProvider::done, this, &DapClient::done);
+    connect(m_dataProvider, &IDataProvider::done, this, &DapClient::done);
-    connect(m_dataProvider.get(), &IDataProvider::started, this, &DapClient::started);
+    connect(m_dataProvider, &IDataProvider::started, this, &DapClient::started);
 }
 
 DapClient::~DapClient() = default;

src/plugins/debugger/dap/dapclient.h

@@ -13,6 +13,8 @@ class IDataProvider : public QObject
 {
     Q_OBJECT
 public:
+    IDataProvider(QObject *parent = nullptr) : QObject(parent) {}
+    ~IDataProvider() override = default;
     virtual void start() = 0;
     virtual bool isRunning() const = 0;
     virtual void writeRaw(const QByteArray &input) = 0;
@@ -64,10 +66,10 @@ class DapClient : public QObject
     Q_OBJECT
 
 public:
-    DapClient(std::unique_ptr<IDataProvider> dataProvider);
+    DapClient(IDataProvider *dataProvider, QObject *parent = nullptr);
-    ~DapClient();
+    ~DapClient() override;
 
-    IDataProvider *dataProvider() const { return m_dataProvider.get(); }
+    IDataProvider *dataProvider() const { return m_dataProvider; }
 
     void postRequest(const QString &command, const QJsonObject &arguments = {});
 
@@ -105,7 +107,7 @@ private:
     void readOutput();
 
 private:
-    std::unique_ptr<IDataProvider> m_dataProvider = nullptr;
+    IDataProvider *m_dataProvider = nullptr;
 
     QByteArray m_inbuffer;
 };

src/plugins/debugger/dap/dapengine.cpp

@@ -70,6 +70,11 @@ DapEngine::DapEngine()
     m_currentWatchItem = m_rootWatchItem;
 }
 
+DapEngine::~DapEngine()
+{
+    delete m_rootWatchItem;
+}
+
 void DapEngine::executeDebuggerCommand(const QString &/*command*/)
 {
     QTC_ASSERT(state() == InferiorStopOk, qCDebug(dapEngineLog) << state());
@@ -787,15 +792,15 @@ void DapEngine::connectDataGeneratorSignals()
     if (!m_dapClient)
         return;
 
-    connect(m_dapClient.get(), &DapClient::started, this, &DapEngine::handleDapStarted);
+    connect(m_dapClient, &DapClient::started, this, &DapEngine::handleDapStarted);
-    connect(m_dapClient.get(), &DapClient::done, this, &DapEngine::handleDapDone);
+    connect(m_dapClient, &DapClient::done, this, &DapEngine::handleDapDone);
-    connect(m_dapClient.get(),
+    connect(m_dapClient,
             &DapClient::readyReadStandardError,
             this,
             &DapEngine::readDapStandardError);
 
-    connect(m_dapClient.get(), &DapClient::responseReady, this, &DapEngine::handleResponse);
+    connect(m_dapClient, &DapClient::responseReady, this, &DapEngine::handleResponse);
-    connect(m_dapClient.get(), &DapClient::eventReady, this, &DapEngine::handleEvent);
+    connect(m_dapClient, &DapClient::eventReady, this, &DapEngine::handleEvent);
 }
 
 DebuggerEngine *createDapEngine(Utils::Id runMode)

src/plugins/debugger/dap/dapengine.h

@@ -27,6 +27,7 @@ class DapEngine : public DebuggerEngine
 {
 public:
     DapEngine();
+    ~DapEngine() override;
 
 protected:
     void executeStepIn(bool) override;
@@ -107,7 +108,7 @@ protected:
     void connectDataGeneratorSignals();
 
     QByteArray m_inbuffer;
-    std::unique_ptr<DapClient> m_dapClient = nullptr;
+    DapClient *m_dapClient = nullptr;
 
     int m_nextBreakpointId = 1;
     int m_currentThreadId = -1;

src/plugins/debugger/dap/gdbdapengine.cpp

@@ -26,8 +26,11 @@ namespace Debugger::Internal {
 class ProcessDataProvider : public IDataProvider
 {
 public:
-    ProcessDataProvider(const DebuggerRunParameters &rp, const CommandLine &cmd)
+    ProcessDataProvider(const DebuggerRunParameters &rp,
-        : m_runParameters(rp)
+                        const CommandLine &cmd,
+                        QObject *parent = nullptr)
+        : IDataProvider(parent)
+        , m_runParameters(rp)
         , m_cmd(cmd)
     {
         connect(&m_proc, &Process::started, this, &IDataProvider::started);
@@ -89,8 +92,8 @@ void GdbDapEngine::setupEngine()
     const DebuggerRunParameters &rp = runParameters();
     const CommandLine cmd{rp.debugger.command.executable(), {"-i", "dap"}};
 
-    std::unique_ptr<IDataProvider> dataProvider = std::make_unique<ProcessDataProvider>(rp, cmd);
+    IDataProvider *dataProvider =  new ProcessDataProvider(rp, cmd, this);
-    m_dapClient = std::make_unique<DapClient>(std::move(dataProvider));
+    m_dapClient = new DapClient(dataProvider, this);
 
     connectDataGeneratorSignals();
     m_dapClient->dataProvider()->start();