ProjectExplorer: Use a QtcProcess member in DeviceProcess

All derived class have one one way or the other. Mid-term plan
would be to actually base DeviceProcess on QtcProcess and to
potentially dissolve it completely later.

Change-Id: Ie3bc48dcdc30bc2da5557ad26babf6959a3efa04
Reviewed-by: Jarek Kobus <jaroslaw.kobus@qt.io>
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>

src/plugins/docker/dockerdevice.cpp

@@ -107,7 +107,7 @@ public:
     void start(const Runnable &runnable) override;
 
     void interrupt() override;
-    void terminate() override { m_process.terminate(); }
+    void terminate() override { process()->terminate(); }
     void kill() override;
 
     QProcess::ProcessState state() const override;
@@ -118,22 +118,18 @@ public:
     QByteArray readAllStandardOutput() override;
     QByteArray readAllStandardError() override;
 
-    qint64 write(const QByteArray &data) override { return m_process.write(data); }
-
-private:
-    QtcProcess m_process;
+    qint64 write(const QByteArray &data) override { return process()->write(data); }
 };
 
 DockerDeviceProcess::DockerDeviceProcess(const QSharedPointer<const IDevice> &device,
                                           QObject *parent)
-    : DeviceProcess(device, parent)
-    , m_process(ProcessMode::Writer)
+    : DeviceProcess(device, ProcessMode::Writer, parent)
 {
 }
 
 void DockerDeviceProcess::start(const Runnable &runnable)
 {
-    QTC_ASSERT(m_process.state() == QProcess::NotRunning, return);
+    QTC_ASSERT(process()->state() == QProcess::NotRunning, return);
     DockerDevice::ConstPtr dockerDevice = qSharedPointerCast<const DockerDevice>(device());
     QTC_ASSERT(dockerDevice, return);
 
@@ -146,65 +142,65 @@ void DockerDeviceProcess::start(const Runnable &runnable)
         MessageManager::writeDisrupting(QString::fromLocal8Bit(readAllStandardError()));
     });
 
-    disconnect(&m_process);
+    disconnect(process());
 
     CommandLine command = runnable.command;
     command.setExecutable(
         command.executable().withNewPath(dockerDevice->mapToDevicePath(command.executable())));
-    m_process.setCommand(command);
-    m_process.setEnvironment(runnable.environment);
-    m_process.setWorkingDirectory(runnable.workingDirectory);
-    connect(&m_process, &QtcProcess::errorOccurred, this, &DeviceProcess::errorOccurred);
-    connect(&m_process, &QtcProcess::finished, this, &DeviceProcess::finished);
-    connect(&m_process, &QtcProcess::readyReadStandardOutput,
+    process()->setCommand(command);
+    process()->setEnvironment(runnable.environment);
+    process()->setWorkingDirectory(runnable.workingDirectory);
+    connect(process(), &QtcProcess::errorOccurred, this, &DeviceProcess::errorOccurred);
+    connect(process(), &QtcProcess::finished, this, &DeviceProcess::finished);
+    connect(process(), &QtcProcess::readyReadStandardOutput,
             this, &DeviceProcess::readyReadStandardOutput);
-    connect(&m_process, &QtcProcess::readyReadStandardError,
+    connect(process(), &QtcProcess::readyReadStandardError,
             this, &DeviceProcess::readyReadStandardError);
-    connect(&m_process, &QtcProcess::started, this, &DeviceProcess::started);
+    connect(process(), &QtcProcess::started, this, &DeviceProcess::started);
 
     LOG("Running process:" << command.toUserOutput()
             << "in" << runnable.workingDirectory.toUserOutput());
-    dockerDevice->runProcess(m_process);
+    dockerDevice->runProcess(*process());
 }
 
 void DockerDeviceProcess::interrupt()
 {
-    device()->signalOperation()->interruptProcess(m_process.processId());
+    device()->signalOperation()->interruptProcess(process()->processId());
 }
 
 void DockerDeviceProcess::kill()
 {
-    m_process.kill();
+    process()->kill();
 }
 
 QProcess::ProcessState DockerDeviceProcess::state() const
 {
-    return m_process.state();
+    return process()->state();
 }
 
 QProcess::ExitStatus DockerDeviceProcess::exitStatus() const
 {
-    return m_process.exitStatus();
+    return process()->exitStatus();
 }
 
 int DockerDeviceProcess::exitCode() const
 {
-    return m_process.exitCode();
+    return process()->exitCode();
 }
 
 QString DockerDeviceProcess::errorString() const
 {
-    return m_process.errorString();
+    return process()->errorString();
 }
 
 QByteArray DockerDeviceProcess::readAllStandardOutput()
 {
-    return m_process.readAllStandardOutput();
+    return process()->readAllStandardOutput();
 }
 
 QByteArray DockerDeviceProcess::readAllStandardError()
 {
-    return m_process.readAllStandardError();
+    return process()->readAllStandardError();
 }
 
 

src/plugins/projectexplorer/devicesupport/desktopdeviceprocess.cpp

@@ -39,76 +39,75 @@ namespace Internal {
 
 DesktopDeviceProcess::DesktopDeviceProcess(const QSharedPointer<const IDevice> &device,
                                            QObject *parent)
-    : DeviceProcess(device, parent)
-    , m_process(ProcessMode::Writer)
+    : DeviceProcess(device, ProcessMode::Writer, parent)
 {
-    connect(&m_process, &QtcProcess::errorOccurred, this, &DeviceProcess::errorOccurred);
-    connect(&m_process, &QtcProcess::finished, this, &DeviceProcess::finished);
-    connect(&m_process, &QtcProcess::readyReadStandardOutput,
+    connect(process(), &QtcProcess::errorOccurred, this, &DeviceProcess::errorOccurred);
+    connect(process(), &QtcProcess::finished, this, &DeviceProcess::finished);
+    connect(process(), &QtcProcess::readyReadStandardOutput,
             this, &DeviceProcess::readyReadStandardOutput);
-    connect(&m_process, &QtcProcess::readyReadStandardError,
+    connect(process(), &QtcProcess::readyReadStandardError,
             this, &DeviceProcess::readyReadStandardError);
-    connect(&m_process, &QtcProcess::started, this, &DeviceProcess::started);
+    connect(process(), &QtcProcess::started, this, &DeviceProcess::started);
 }
 
 void DesktopDeviceProcess::start(const Runnable &runnable)
 {
-    QTC_ASSERT(m_process.state() == QProcess::NotRunning, return);
+    QTC_ASSERT(process()->state() == QProcess::NotRunning, return);
     if (runnable.environment.size())
-        m_process.setEnvironment(runnable.environment);
-    m_process.setWorkingDirectory(runnable.workingDirectory);
-    m_process.setCommand(runnable.command);
-    m_process.start();
+        process()->setEnvironment(runnable.environment);
+    process()->setWorkingDirectory(runnable.workingDirectory);
+    process()->setCommand(runnable.command);
+    process()->start();
 }
 
 void DesktopDeviceProcess::interrupt()
 {
-    device()->signalOperation()->interruptProcess(m_process.processId());
+    device()->signalOperation()->interruptProcess(process()->processId());
 }
 
 void DesktopDeviceProcess::terminate()
 {
-    m_process.terminate();
+    process()->terminate();
 }
 
 void DesktopDeviceProcess::kill()
 {
-    m_process.kill();
+    process()->kill();
 }
 
 QProcess::ProcessState DesktopDeviceProcess::state() const
 {
-    return m_process.state();
+    return process()->state();
 }
 
 QProcess::ExitStatus DesktopDeviceProcess::exitStatus() const
 {
-    return m_process.exitStatus();
+    return process()->exitStatus();
 }
 
 int DesktopDeviceProcess::exitCode() const
 {
-    return m_process.exitCode();
+    return process()->exitCode();
 }
 
 QString DesktopDeviceProcess::errorString() const
 {
-    return m_process.errorString();
+    return process()->errorString();
 }
 
 QByteArray DesktopDeviceProcess::readAllStandardOutput()
 {
-    return m_process.readAllStandardOutput();
+    return process()->readAllStandardOutput();
 }
 
 QByteArray DesktopDeviceProcess::readAllStandardError()
 {
-    return m_process.readAllStandardError();
+    return process()->readAllStandardError();
 }
 
 qint64 DesktopDeviceProcess::write(const QByteArray &data)
 {
-    return m_process.write(data);
+    return process()->write(data);
 }
 
 } // namespace Internal

src/plugins/projectexplorer/devicesupport/desktopdeviceprocess.h

@@ -53,9 +53,6 @@ public:
     QByteArray readAllStandardError() override;
 
     qint64 write(const QByteArray &data) override;
-
-private:
-    Utils::QtcProcess m_process;
 };
 
 } // namespace Internal

src/plugins/projectexplorer/devicesupport/deviceprocess.cpp

@@ -30,10 +30,14 @@
 #include <utils/qtcassert.h>
 #include <utils/fileutils.h>
 
+using namespace Utils;
+
 namespace ProjectExplorer {
 
-DeviceProcess::DeviceProcess(const IDevice::ConstPtr &device, QObject *parent)
-    : QObject(parent), m_device(device)
+DeviceProcess::DeviceProcess(const IDevice::ConstPtr &device,
+                             const QtcProcess::Setup &setup,
+                             QObject *parent)
+    : QObject(parent), m_process(setup), m_device(device)
 {
 }
 

src/plugins/projectexplorer/devicesupport/deviceprocess.h

@@ -27,8 +27,9 @@
 
 #include "../projectexplorer_export.h"
 
+#include <utils/qtcprocess.h>
+
 #include <QObject>
-#include <QProcess>
 #include <QSharedPointer>
 #include <QStringList>
 
@@ -68,10 +69,16 @@ signals:
     void readyReadStandardError();
 
 protected:
-    explicit DeviceProcess(const QSharedPointer<const IDevice> &device, QObject *parent = nullptr);
+    explicit DeviceProcess(const QSharedPointer<const IDevice> &device,
+                           const Utils::QtcProcess::Setup &setup,
+                           QObject *parent = nullptr);
+
     QSharedPointer<const IDevice> device() const;
+    Utils::QtcProcess *process() { return &m_process; }
+    const Utils::QtcProcess *process() const { return &m_process; }
 
 private:
+    Utils::QtcProcess m_process;
     const QSharedPointer<const IDevice> m_device;
     bool m_runInTerminal = false;
 };

src/plugins/projectexplorer/devicesupport/sshdeviceprocess.cpp

@@ -48,12 +48,11 @@ enum class Signal { Interrupt, Terminate, Kill };
 class SshDeviceProcess::SshDeviceProcessPrivate
 {
 public:
-    SshDeviceProcessPrivate(SshDeviceProcess *q) : q(q), consoleProcess(QtcProcess::TerminalOn) {}
+    SshDeviceProcessPrivate(SshDeviceProcess *q) : q(q) {}
 
     SshDeviceProcess * const q;
     QSsh::SshConnection *connection = nullptr;
-    QSsh::SshRemoteProcessPtr process;
-    QtcProcess consoleProcess;
+    QSsh::SshRemoteProcessPtr remoteProcess;
     Runnable runnable;
     QString errorMessage;
     QProcess::ExitStatus exitStatus = QProcess::NormalExit;
@@ -74,7 +73,8 @@ public:
 };
 
 SshDeviceProcess::SshDeviceProcess(const IDevice::ConstPtr &device, QObject *parent)
-    : DeviceProcess(device, parent), d(std::make_unique<SshDeviceProcessPrivate>(this))
+    : DeviceProcess(device, QtcProcess::TerminalOn, parent),
+      d(std::make_unique<SshDeviceProcessPrivate>(this))
 {
     connect(&d->killTimer, &QTimer::timeout, this, &SshDeviceProcess::handleKillOperationTimeout);
 }
@@ -185,32 +185,32 @@ void SshDeviceProcess::handleConnected()
     QTC_ASSERT(d->state == SshDeviceProcessPrivate::Connecting, return);
     d->setState(SshDeviceProcessPrivate::Connected);
 
-    d->process = runInTerminal() && d->runnable.command.isEmpty()
+    d->remoteProcess = runInTerminal() && d->runnable.command.isEmpty()
             ? d->connection->createRemoteShell()
             : d->connection->createRemoteProcess(fullCommandLine(d->runnable));
     const QString display = d->displayName();
     if (!display.isEmpty())
-        d->process->requestX11Forwarding(display);
+        d->remoteProcess->requestX11Forwarding(display);
     if (runInTerminal()) {
-        connect(&d->consoleProcess, &QtcProcess::errorOccurred,
+        connect(process(), &QtcProcess::errorOccurred,
                 this, &DeviceProcess::errorOccurred);
-        connect(&d->consoleProcess, &QtcProcess::started,
+        connect(process(), &QtcProcess::started,
                 this, &SshDeviceProcess::handleProcessStarted);
-        connect(&d->consoleProcess, &QtcProcess::finished,
-                this, [this] { handleProcessFinished(d->consoleProcess.errorString()); });
-        d->consoleProcess.setAbortOnMetaChars(false);
-        d->consoleProcess.setCommand(d->process->fullLocalCommandLine(true));
-        d->consoleProcess.start();
+        connect(process(), &QtcProcess::finished,
+                this, [this] { handleProcessFinished(process()->errorString()); });
+        process()->setAbortOnMetaChars(false);
+        process()->setCommand(d->remoteProcess->fullLocalCommandLine(true));
+        process()->start();
     } else {
-        connect(d->process.get(), &QSsh::SshRemoteProcess::started,
+        connect(d->remoteProcess.get(), &QSsh::SshRemoteProcess::started,
                 this, &SshDeviceProcess::handleProcessStarted);
-        connect(d->process.get(), &QSsh::SshRemoteProcess::done,
+        connect(d->remoteProcess.get(), &QSsh::SshRemoteProcess::done,
                 this, &SshDeviceProcess::handleProcessFinished);
-        connect(d->process.get(), &QSsh::SshRemoteProcess::readyReadStandardOutput,
+        connect(d->remoteProcess.get(), &QSsh::SshRemoteProcess::readyReadStandardOutput,
                 this, &SshDeviceProcess::handleStdout);
-        connect(d->process.get(), &QSsh::SshRemoteProcess::readyReadStandardError,
+        connect(d->remoteProcess.get(), &QSsh::SshRemoteProcess::readyReadStandardError,
                 this, &SshDeviceProcess::handleStderr);
-        d->process->start();
+        d->remoteProcess->start();
     }
 }
 
@@ -251,7 +251,7 @@ void SshDeviceProcess::handleProcessStarted()
 void SshDeviceProcess::handleProcessFinished(const QString &error)
 {
     d->errorMessage = error;
-    d->exitCode = runInTerminal() ? d->consoleProcess.exitCode() : d->process->exitCode();
+    d->exitCode = runInTerminal() ? process()->exitCode() : d->remoteProcess->exitCode();
     if (d->killOperation && error.isEmpty())
         d->errorMessage = tr("The process was ended forcefully.");
     d->setState(SshDeviceProcessPrivate::Inactive);
@@ -260,7 +260,7 @@ void SshDeviceProcess::handleProcessFinished(const QString &error)
 
 void SshDeviceProcess::handleStdout()
 {
-    QByteArray output = d->process->readAllStandardOutput();
+    QByteArray output = d->remoteProcess->readAllStandardOutput();
     if (output.isEmpty())
         return;
     d->stdOut += output;
@@ -269,7 +269,7 @@ void SshDeviceProcess::handleStdout()
 
 void SshDeviceProcess::handleStderr()
 {
-    QByteArray output = d->process->readAllStandardError();
+    QByteArray output = d->remoteProcess->readAllStandardError();
     if (output.isEmpty())
         return;
     d->stdErr += output;
@@ -356,12 +356,12 @@ void SshDeviceProcess::SshDeviceProcessPrivate::setState(SshDeviceProcess::SshDe
         killOperation->disconnect(q);
         killOperation.clear();
         if (q->runInTerminal())
-            QMetaObject::invokeMethod(&consoleProcess, &QtcProcess::stopProcess, Qt::QueuedConnection);
+            QMetaObject::invokeMethod(q->process(), &QtcProcess::stopProcess, Qt::QueuedConnection);
     }
     killTimer.stop();
-    consoleProcess.disconnect();
-    if (process)
-        process->disconnect(q);
+    q->process()->disconnect();
+    if (remoteProcess)
+        remoteProcess->disconnect(q);
     if (connection) {
         connection->disconnect(q);
         QSsh::SshConnectionManager::releaseConnection(connection);
@@ -372,7 +372,7 @@ void SshDeviceProcess::SshDeviceProcessPrivate::setState(SshDeviceProcess::SshDe
 qint64 SshDeviceProcess::write(const QByteArray &data)
 {
     QTC_ASSERT(!runInTerminal(), return -1);
-    return d->process->write(data);
+    return d->remoteProcess->write(data);
 }
 
 } // namespace ProjectExplorer