Implement ProcessLauncher::processId()

Implement the reply confirmation for the started signal.
After qtcreator_processlauncher starts a new process
we connect to its started() signal and post a reply through
the socket to the LauncherInterface with the information about
the new PID. ProcessLauncherImpl now emits the started signal
with a delay, just after the confirmation has been received.

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

src/libs/utils/launcherpackets.cpp

@@ -67,6 +67,22 @@ void StartProcessPacket::doDeserialize(QDataStream &stream)
 }
 
 
+ProcessStartedPacket::ProcessStartedPacket(quintptr token)
+    : LauncherPacket(LauncherPacketType::ProcessStarted, token)
+{
+}
+
+void ProcessStartedPacket::doSerialize(QDataStream &stream) const
+{
+    stream << processId;
+}
+
+void ProcessStartedPacket::doDeserialize(QDataStream &stream)
+{
+    stream >> processId;
+}
+
+
 StopProcessPacket::StopProcessPacket(quintptr token)
     : LauncherPacket(LauncherPacketType::StopProcess, token)
 {

src/libs/utils/launcherpackets.h

@@ -37,7 +37,7 @@ namespace Utils {
 namespace Internal {
 
 enum class LauncherPacketType {
-    Shutdown, StartProcess, StopProcess, ProcessError, ProcessFinished
+    Shutdown, StartProcess, ProcessStarted, StopProcess, ProcessError, ProcessFinished
 };
 
 class PacketParser
@@ -106,6 +106,18 @@ private:
     void doDeserialize(QDataStream &stream) override;
 };
 
+class ProcessStartedPacket : public LauncherPacket
+{
+public:
+    ProcessStartedPacket(quintptr token);
+
+    int processId;
+
+private:
+    void doSerialize(QDataStream &stream) const override;
+    void doDeserialize(QDataStream &stream) override;
+};
+
 class StopProcessPacket : public LauncherPacket
 {
 public:

src/libs/utils/launchersocket.cpp

@@ -100,6 +100,7 @@ void LauncherSocket::handleSocketDataAvailable()
     }
     switch (m_packetParser.type()) {
     case LauncherPacketType::ProcessError:
+    case LauncherPacketType::ProcessStarted:
     case LauncherPacketType::ProcessFinished:
         emit packetArrived(m_packetParser.type(), m_packetParser.token(),
                            m_packetParser.packetData());

src/libs/utils/qtcprocess.cpp

@@ -315,7 +315,7 @@ public:
     QString program() const override { return m_command; }
     QProcess::ProcessError error() const override { return m_error; }
     QProcess::ProcessState state() const override { return m_state; }
-    qint64 processId() const override { QTC_CHECK(false); return 0; }
+    qint64 processId() const override { return m_processId; }
     QProcess::ExitStatus exitStatus() const override { QTC_CHECK(false); return QProcess::NormalExit; }
     QString errorString() const override { return m_errorString; }
     void setErrorString(const QString &str) override { m_errorString = str; }
@@ -352,6 +352,7 @@ private:
     void handlePacket(Internal::LauncherPacketType type, quintptr token,
                       const QByteArray &payload);
     void handleErrorPacket(const QByteArray &packetData);
+    void handleStartedPacket(const QByteArray &packetData);
     void handleFinishedPacket(const QByteArray &packetData);
     void handleSocketReady();
 
@@ -367,6 +368,7 @@ private:
     QProcess::ProcessError m_error = QProcess::UnknownError;
     QProcess::ProcessState m_state = QProcess::NotRunning;
     QProcess::ProcessChannelMode m_channelMode = QProcess::SeparateChannels;
+    int m_processId = 0;
     int m_exitCode = 0;
     bool m_canceled = false;
     bool m_socketError = false;
@@ -389,8 +391,6 @@ void ProcessLauncherImpl::start(const QString &program, const QStringList &argum
 
 void ProcessLauncherImpl::doStart()
 {
-    emit started(); // Should be queued in order to behave the same as QProcess?
-    m_state = QProcess::Running;
     StartProcessPacket p(token());
     p.command = m_command;
     p.arguments = m_arguments;
@@ -412,7 +412,10 @@ void ProcessLauncherImpl::cancel()
                                                     "Process canceled before it was started.");
         m_error = QProcess::FailedToStart;
         m_state = QProcess::NotRunning;
-        emit errorOccurred(m_error);
+        if (LauncherInterface::socket()->isReady())
+            sendPacket(StopProcessPacket(token()));
+        else
+            emit errorOccurred(m_error);
         break;
     case QProcess::Running:
         sendPacket(StopProcessPacket(token()));
@@ -430,6 +433,9 @@ void ProcessLauncherImpl::handlePacket(LauncherPacketType type, quintptr token,
     case LauncherPacketType::ProcessError:
         handleErrorPacket(payload);
         break;
+    case LauncherPacketType::ProcessStarted:
+        handleStartedPacket(payload);
+        break;
     case LauncherPacketType::ProcessFinished:
         handleFinishedPacket(payload);
         break;
@@ -467,6 +473,17 @@ void ProcessLauncherImpl::handleErrorPacket(const QByteArray &packetData)
     emit errorOccurred(m_error);
 }
 
+void ProcessLauncherImpl::handleStartedPacket(const QByteArray &packetData)
+{
+    if (m_canceled)
+        return;
+    QTC_ASSERT(m_state == QProcess::Starting, return);
+    m_state = QProcess::Running;
+    const auto packet = LauncherPacket::extractPacket<ProcessStartedPacket>(token(), packetData);
+    m_processId = packet.processId;
+    emit started();
+}
+
 void ProcessLauncherImpl::handleFinishedPacket(const QByteArray &packetData)
 {
     if (m_canceled)

src/tools/processlauncher/launchersockethandler.cpp

@@ -178,6 +178,14 @@ void LauncherSocketHandler::handleProcessError()
     sendPacket(packet);
 }
 
+void LauncherSocketHandler::handleProcessStarted()
+{
+    Process *proc = senderProcess();
+    ProcessStartedPacket packet(proc->token());
+    packet.processId = proc->processId();
+    sendPacket(packet);
+}
+
 void LauncherSocketHandler::handleProcessFinished()
 {
     Process * proc = senderProcess();
@@ -265,6 +273,7 @@ Process *LauncherSocketHandler::setupProcess(quintptr token)
 {
     const auto p = new Process(token, this);
     connect(p, &QProcess::errorOccurred, this, &LauncherSocketHandler::handleProcessError);
+    connect(p, &QProcess::started, this, &LauncherSocketHandler::handleProcessStarted);
     connect(p, static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished),
             this, &LauncherSocketHandler::handleProcessFinished);
     connect(p, &Process::failedToStop, this, &LauncherSocketHandler::handleStopFailure);

src/tools/processlauncher/launchersockethandler.h

@@ -53,6 +53,7 @@ private:
     void handleSocketError();
     void handleSocketClosed();
     void handleProcessError();
+    void handleProcessStarted();
     void handleProcessFinished();
     void handleStopFailure();