SSH: Name SshRemoteProcess::ExitStatus values like the QProcess ones.

(We cannot use QProcess::ExitStatus itself, because it does not contain
FailedToStart.)

Change-Id: I83ed6de621e2693e539562cd8e56ef478fa4fcb9
Reviewed-by: hjk <qthjk@ovi.com>

src/libs/ssh/sshremoteprocess.cpp

@@ -280,9 +280,9 @@ void SshRemoteProcessPrivate::closeHook()
 {
     if (m_wasRunning) {
         if (m_signal != SshRemoteProcess::NoSignal)
-            emit closed(SshRemoteProcess::KilledBySignal);
+            emit closed(SshRemoteProcess::CrashExit);
         else
-            emit closed(SshRemoteProcess::ExitedNormally);
+            emit closed(SshRemoteProcess::NormalExit);
     }
 }
 

src/libs/ssh/sshremoteprocess.h

@@ -60,7 +60,7 @@ class QSSH_EXPORT SshRemoteProcess : public QIODevice
 
 public:
     typedef QSharedPointer<SshRemoteProcess> Ptr;
-    enum ExitStatus { FailedToStart, KilledBySignal, ExitedNormally };
+    enum ExitStatus { FailedToStart, CrashExit, NormalExit };
     enum Signal {
         AbrtSignal, AlrmSignal, FpeSignal, HupSignal, IllSignal, IntSignal, KillSignal, PipeSignal,
         QuitSignal, SegvSignal, TermSignal, Usr1Signal, Usr2Signal, NoSignal

src/libs/ssh/sshremoteprocessrunner.cpp

@@ -169,11 +169,11 @@ void SshRemoteProcessRunner::handleProcessFinished(int exitStatus)
     case SshRemoteProcess::FailedToStart:
         QSSH_ASSERT_AND_RETURN(d->m_state == Connected);
         break;
-    case SshRemoteProcess::KilledBySignal:
+    case SshRemoteProcess::CrashExit:
         QSSH_ASSERT_AND_RETURN(d->m_state == ProcessRunning);
         d->m_exitSignal = d->m_process->exitSignal();
         break;
-    case SshRemoteProcess::ExitedNormally:
+    case SshRemoteProcess::NormalExit:
         QSSH_ASSERT_AND_RETURN(d->m_state == ProcessRunning);
         d->m_exitCode = d->m_process->exitCode();
         break;
@@ -234,13 +234,13 @@ SshRemoteProcess::ExitStatus SshRemoteProcessRunner::processExitStatus() const
 
 SshRemoteProcess::Signal SshRemoteProcessRunner::processExitSignal() const
 {
-    QSSH_ASSERT(processExitStatus() == SshRemoteProcess::KilledBySignal);
+    QSSH_ASSERT(processExitStatus() == SshRemoteProcess::CrashExit);
     return d->m_exitSignal;
 }
 
 int SshRemoteProcessRunner::processExitCode() const
 {
-    QSSH_ASSERT(processExitStatus() == SshRemoteProcess::ExitedNormally);
+    QSSH_ASSERT(processExitStatus() == SshRemoteProcess::NormalExit);
     return d->m_exitCode;
 }
 

src/plugins/debugger/gdb/remotegdbprocess.cpp

@@ -130,7 +130,7 @@ void RemoteGdbProcess::handleFifoCreationFinished(int exitStatus)
         return;
     QTC_ASSERT(m_state == CreatingFifo, return);
 
-    if (exitStatus != QSsh::SshRemoteProcess::ExitedNormally) {
+    if (exitStatus != QSsh::SshRemoteProcess::NormalExit) {
         emitErrorExit(tr("Could not create FIFO."));
     } else {
         setState(StartingFifoReader);
@@ -172,7 +172,7 @@ void RemoteGdbProcess::handleAppOutputReaderStarted()
 
 void RemoteGdbProcess::handleAppOutputReaderFinished(int exitStatus)
 {
-    if (exitStatus != QSsh::SshRemoteProcess::ExitedNormally)
+    if (exitStatus != QSsh::SshRemoteProcess::NormalExit)
         emitErrorExit(tr("Application output reader unexpectedly finished."));
 }
 
@@ -197,10 +197,10 @@ void RemoteGdbProcess::handleGdbFinished(int exitStatus)
         setState(Inactive);
         emit startFailed();
         break;
-    case QSsh::SshRemoteProcess::KilledBySignal:
+    case QSsh::SshRemoteProcess::CrashExit:
         emitErrorExit(tr("Remote GDB crashed."));
         break;
-    case QSsh::SshRemoteProcess::ExitedNormally:
+    case QSsh::SshRemoteProcess::NormalExit:
         const int exitCode = m_gdbProc->exitCode();
         setState(Inactive);
         emit finished(exitCode, QProcess::NormalExit);

src/plugins/madde/maddedevicetester.cpp

@@ -176,7 +176,7 @@ void MaddeDeviceTester::handleProcessFinished(int exitStatus)
 
 void MaddeDeviceTester::handleQtTestFinished(int exitStatus)
 {
-    if (exitStatus != SshRemoteProcess::ExitedNormally
+    if (exitStatus != SshRemoteProcess::NormalExit
             || m_processRunner->processExitCode() != 0) {
         if (!m_stderr.isEmpty()) {
             emit errorMessage(tr("Error checking for Qt libraries: %1\n")
@@ -201,7 +201,7 @@ void MaddeDeviceTester::handleQtTestFinished(int exitStatus)
 
 void MaddeDeviceTester::handleMadDeveloperTestFinished(int exitStatus)
 {
-    if (exitStatus != SshRemoteProcess::ExitedNormally) {
+    if (exitStatus != SshRemoteProcess::NormalExit) {
         if (!m_stderr.isEmpty()) {
             emit errorMessage(tr("Error checking for connectivity tool: %1\n")
                 .arg(QString::fromUtf8(m_stderr)));
@@ -238,7 +238,7 @@ void MaddeDeviceTester::handleMadDeveloperTestFinished(int exitStatus)
 
 void MaddeDeviceTester::handleQmlToolingTestFinished(int exitStatus)
 {
-    if (exitStatus != SshRemoteProcess::ExitedNormally) {
+    if (exitStatus != SshRemoteProcess::NormalExit) {
         if (!m_stderr.isEmpty()) {
             emit errorMessage(tr("Error checking for QML tooling support: %1\n")
                 .arg(QString::fromUtf8(m_stderr)));

src/plugins/madde/maemopublisherfremantlefree.cpp

@@ -424,10 +424,10 @@ void MaemoPublisherFremantleFree::handleUploadJobFinished(int exitStatus)
     QTC_ASSERT(m_state == PreparingToUploadFile || m_state == UploadingFile || m_state ==Inactive,
         return);
 
-    if (m_state != Inactive && (exitStatus != SshRemoteProcess::ExitedNormally
+    if (m_state != Inactive && (exitStatus != SshRemoteProcess::NormalExit
             || m_uploader->processExitCode() != 0)) {
         QString error;
-        if (exitStatus != SshRemoteProcess::ExitedNormally) {
+        if (exitStatus != SshRemoteProcess::NormalExit) {
             error = tr("Error uploading file: %1.")
                 .arg(m_uploader->processErrorString());
         } else {

src/plugins/madde/maemoremotecopyfacility.cpp

@@ -107,7 +107,7 @@ void MaemoRemoteCopyFacility::handleCopyFinished(int exitStatus)
     if (!m_isCopying)
         return;
 
-    if (exitStatus != SshRemoteProcess::ExitedNormally
+    if (exitStatus != SshRemoteProcess::NormalExit
             || m_copyRunner->processExitCode() != 0) {
         setFinished();
         emit finished(tr("Error: Copy command failed."));

src/plugins/madde/maemoremotemounter.cpp

@@ -157,11 +157,11 @@ void MaemoRemoteMounter::handleUnmountProcessFinished(int exitStatus)
     case SshRemoteProcess::FailedToStart:
         errorMsg = tr("Could not execute unmount request.");
         break;
-    case SshRemoteProcess::KilledBySignal:
+    case SshRemoteProcess::CrashExit:
         errorMsg = tr("Failure unmounting: %1")
             .arg(m_unmountProcess->errorString());
         break;
-    case SshRemoteProcess::ExitedNormally:
+    case SshRemoteProcess::NormalExit:
         break;
     default:
         Q_ASSERT_X(false, Q_FUNC_INFO,
@@ -255,7 +255,7 @@ void MaemoRemoteMounter::handleUtfsClientsFinished(int exitStatus)
         return;
 
     setState(Inactive);
-    if (exitStatus == SshRemoteProcess::ExitedNormally
+    if (exitStatus == SshRemoteProcess::NormalExit
             && m_mountProcess->exitCode() == 0) {
         emit reportProgress(tr("Mount operation succeeded."));
         emit mounted();

src/plugins/remotelinux/genericdirectuploadservice.cpp

@@ -192,7 +192,7 @@ void GenericDirectUploadService::handleLnFinished(int exitStatus)
 
     const DeployableFile df = d->filesToUpload.takeFirst();
     const QString nativePath = QDir::toNativeSeparators(df.localFilePath);
-    if (exitStatus != SshRemoteProcess::ExitedNormally || d->lnProc->exitCode() != 0) {
+    if (exitStatus != SshRemoteProcess::NormalExit || d->lnProc->exitCode() != 0) {
         emit errorMessage(tr("Failed to upload file '%1'.").arg(nativePath));
         setFinished();
         handleDeploymentDone();
@@ -215,7 +215,7 @@ void GenericDirectUploadService::handleMkdirFinished(int exitStatus)
     const DeployableFile &df = d->filesToUpload.first();
     QFileInfo fi(df.localFilePath);
     const QString nativePath = QDir::toNativeSeparators(df.localFilePath);
-    if (exitStatus != SshRemoteProcess::ExitedNormally || d->mkdirProc->exitCode() != 0) {
+    if (exitStatus != SshRemoteProcess::NormalExit || d->mkdirProc->exitCode() != 0) {
         emit errorMessage(tr("Failed to upload file '%1'.").arg(nativePath));
         setFinished();
         handleDeploymentDone();

src/plugins/remotelinux/linuxdevicetester.cpp

@@ -141,7 +141,7 @@ void GenericLinuxDeviceTester::handleProcessFinished(int exitStatus)
 {
     QTC_ASSERT(d->state == RunningUname, return);
 
-    if (exitStatus != SshRemoteProcess::ExitedNormally || d->process->exitCode() != 0) {
+    if (exitStatus != SshRemoteProcess::NormalExit || d->process->exitCode() != 0) {
         const QByteArray stderrOutput = d->process->readAllStandardError();
         if (!stderrOutput.isEmpty())
             emit errorMessage(tr("uname failed: %1\n").arg(QString::fromUtf8(stderrOutput)));

src/plugins/remotelinux/remotelinuxapplicationrunner.cpp

@@ -234,8 +234,8 @@ void AbstractRemoteLinuxApplicationRunner::cleanup()
 void AbstractRemoteLinuxApplicationRunner::handleCleanupFinished(int exitStatus)
 {
     Q_ASSERT(exitStatus == SshRemoteProcess::FailedToStart
-        || exitStatus == SshRemoteProcess::KilledBySignal
+        || exitStatus == SshRemoteProcess::CrashExit
-        || exitStatus == SshRemoteProcess::ExitedNormally);
+        || exitStatus == SshRemoteProcess::NormalExit);
 
     QTC_ASSERT(d->state == PreRunCleaning
         || (d->state == ProcessStarted && d->stopRequested) || d->state == Inactive, return);
@@ -253,7 +253,7 @@ void AbstractRemoteLinuxApplicationRunner::handleCleanupFinished(int exitStatus)
         return;
     }
 
-    if (exitStatus != SshRemoteProcess::ExitedNormally) {
+    if (exitStatus != SshRemoteProcess::NormalExit) {
         emitError(tr("Initial cleanup failed: %1").arg(d->cleaner->errorString()));
         emit remoteProcessFinished(InvalidExitCode);
         return;
@@ -296,8 +296,8 @@ void AbstractRemoteLinuxApplicationRunner::handleRemoteProcessStarted()
 void AbstractRemoteLinuxApplicationRunner::handleRemoteProcessFinished(int exitStatus)
 {
     Q_ASSERT(exitStatus == SshRemoteProcess::FailedToStart
-        || exitStatus == SshRemoteProcess::KilledBySignal
+        || exitStatus == SshRemoteProcess::CrashExit
-        || exitStatus == SshRemoteProcess::ExitedNormally);
+        || exitStatus == SshRemoteProcess::NormalExit);
     QTC_ASSERT(d->state == ProcessStarted || d->state == Inactive, return);
 
     d->exitStatus = exitStatus;
@@ -454,7 +454,7 @@ void AbstractRemoteLinuxApplicationRunner::handlePostRunCleanupDone()
     setInactive();
     if (wasStopRequested)
         emit remoteProcessFinished(InvalidExitCode);
-    else if (d->exitStatus == SshRemoteProcess::ExitedNormally)
+    else if (d->exitStatus == SshRemoteProcess::NormalExit)
         emit remoteProcessFinished(d->runner->exitCode());
     else
         emit error(tr("Error running remote process: %1").arg(d->runner->errorString()));

src/plugins/remotelinux/remotelinuxcheckforfreediskspaceservice.cpp

@@ -91,11 +91,11 @@ void RemoteLinuxCheckForFreeDiskSpaceService::handleProcessFinished()
         emit errorMessage(tr("Remote process failed to start."));
         stopDeployment();
         return;
-    case QSsh::SshRemoteProcess::KilledBySignal:
+    case QSsh::SshRemoteProcess::CrashExit:
         emit errorMessage(tr("Remote process crashed."));
         stopDeployment();
         return;
-    case QSsh::SshRemoteProcess::ExitedNormally:
+    case QSsh::SshRemoteProcess::NormalExit:
         break;
     }
 

src/plugins/remotelinux/remotelinuxcustomcommanddeployservice.cpp

@@ -136,7 +136,7 @@ void RemoteLinuxCustomCommandDeployService::handleProcessClosed(int exitStatus)
 
     if (exitStatus == SshRemoteProcess::FailedToStart) {
         emit errorMessage(tr("Remote process failed to start."));
-    } else if (exitStatus == SshRemoteProcess::KilledBySignal) {
+    } else if (exitStatus == SshRemoteProcess::CrashExit) {
         emit errorMessage(tr("Remote process was killed by a signal."));
     } else if (d->runner->processExitCode() != 0) {
         emit errorMessage(tr("Remote process finished with exit code %1.")

src/plugins/remotelinux/remotelinuxenvironmentreader.cpp

@@ -103,15 +103,15 @@ void RemoteLinuxEnvironmentReader::handleCurrentDeviceConfigChanged()
 void RemoteLinuxEnvironmentReader::remoteProcessFinished(int exitCode)
 {
     Q_ASSERT(exitCode == QSsh::SshRemoteProcess::FailedToStart
-        || exitCode == QSsh::SshRemoteProcess::KilledBySignal
+        || exitCode == QSsh::SshRemoteProcess::CrashExit
-        || exitCode == QSsh::SshRemoteProcess::ExitedNormally);
+        || exitCode == QSsh::SshRemoteProcess::NormalExit);
 
     if (m_stop)
         return;
 
     disconnect(m_remoteProcessRunner, 0, this, 0);
     m_env.clear();
-    if (exitCode == QSsh::SshRemoteProcess::ExitedNormally) {
+    if (exitCode == QSsh::SshRemoteProcess::NormalExit) {
         if (!m_remoteOutput.isEmpty()) {
             m_env = Utils::Environment(m_remoteOutput.split(QLatin1Char('\n'),
                 QString::SkipEmptyParts));

src/plugins/remotelinux/remotelinuxpackageinstaller.cpp

@@ -112,7 +112,7 @@ void AbstractRemoteLinuxPackageInstaller::handleInstallationFinished(int exitSta
     if (!d->isRunning)
         return;
 
-    if (exitStatus != SshRemoteProcess::ExitedNormally || d->installer->processExitCode() != 0) {
+    if (exitStatus != SshRemoteProcess::NormalExit || d->installer->processExitCode() != 0) {
         emit finished(tr("Installing package failed."));
     } else if (!errorString().isEmpty()) {
         emit finished(errorString());

src/plugins/remotelinux/remotelinuxprocesslist.cpp

@@ -184,11 +184,11 @@ void AbstractRemoteLinuxProcessList::handleRemoteProcessFinished(int exitStatus)
         d->errorMsg = tr("Error: Remote process failed to start: %1")
             .arg(d->process.processErrorString());
         break;
-    case SshRemoteProcess::KilledBySignal:
+    case SshRemoteProcess::CrashExit:
         d->errorMsg = tr("Error: Remote process crashed: %1")
             .arg(d->process.processErrorString());
         break;
-    case SshRemoteProcess::ExitedNormally:
+    case SshRemoteProcess::NormalExit:
         if (d->process.processExitCode() == 0) {
             if (d->state == Listing) {
                 beginResetModel();

src/plugins/remotelinux/remotelinuxusedportsgatherer.cpp

@@ -178,10 +178,10 @@ void RemoteLinuxUsedPortsGatherer::handleProcessClosed(int exitStatus)
     case SshRemoteProcess::FailedToStart:
         errMsg = tr("Could not start remote process: %1").arg(d->process->errorString());
         break;
-    case SshRemoteProcess::KilledBySignal:
+    case SshRemoteProcess::CrashExit:
         errMsg = tr("Remote process crashed: %1").arg(d->process->errorString());
         break;
-    case SshRemoteProcess::ExitedNormally:
+    case SshRemoteProcess::NormalExit:
         if (d->process->exitCode() == 0)
             setupUsedPorts();
         else

src/plugins/remotelinux/sshkeydeployer.cpp

@@ -88,13 +88,13 @@ void SshKeyDeployer::handleConnectionFailure()
 void SshKeyDeployer::handleKeyUploadFinished(int exitStatus)
 {
     Q_ASSERT(exitStatus == SshRemoteProcess::FailedToStart
-        || exitStatus == SshRemoteProcess::KilledBySignal
+        || exitStatus == SshRemoteProcess::CrashExit
-        || exitStatus == SshRemoteProcess::ExitedNormally);
+        || exitStatus == SshRemoteProcess::NormalExit);
 
     const int exitCode = d->deployProcess.processExitCode();
     const QString errorMsg = d->deployProcess.processErrorString();
     cleanup();
-    if (exitStatus == SshRemoteProcess::ExitedNormally && exitCode == 0)
+    if (exitStatus == SshRemoteProcess::NormalExit && exitCode == 0)
         emit finishedSuccessfully();
     else
         emit error(tr("Key deployment failed: %1.").arg(errorMsg));

src/plugins/valgrind/valgrindprocess.cpp

@@ -324,9 +324,9 @@ void RemoteValgrindProcess::closed(int status)
     if (status == QSsh::SshRemoteProcess::FailedToStart) {
         m_error = QProcess::FailedToStart;
         emit ValgrindProcess::error(QProcess::FailedToStart);
-    } else if (status == QSsh::SshRemoteProcess::ExitedNormally) {
+    } else if (status == QSsh::SshRemoteProcess::NormalExit) {
         emit finished(m_process->exitCode(), QProcess::NormalExit);
-    } else if (status == QSsh::SshRemoteProcess::KilledBySignal) {
+    } else if (status == QSsh::SshRemoteProcess::CrashExit) {
         m_error = QProcess::Crashed;
         emit finished(m_process->exitCode(), QProcess::CrashExit);
     }

tests/manual/ssh/remoteprocess/remoteprocesstest.cpp

@@ -142,7 +142,7 @@ void RemoteProcessTest::handleProcessStderr(const QByteArray &output)
 void RemoteProcessTest::handleProcessClosed(int exitStatus)
 {
     switch (exitStatus) {
-    case SshRemoteProcess::ExitedNormally:
+    case SshRemoteProcess::NormalExit:
         if (!m_started) {
             std::cerr << "Error: Process exited without starting." << std::endl;
             qApp->quit();
@@ -263,7 +263,7 @@ void RemoteProcessTest::handleProcessClosed(int exitStatus)
         }
         qApp->quit();
         break;
-    case SshRemoteProcess::KilledBySignal:
+    case SshRemoteProcess::CrashExit:
         switch (m_state) {
         case TestingCrash:
             handleSuccessfulCrashTest();

tests/manual/ssh/shell/shell.cpp

@@ -110,7 +110,7 @@ void Shell::handleChannelClosed(int exitStatus)
 {
     std::cerr << "Shell closed. Exit status was " << exitStatus << ", exit code was "
         << m_shell->exitCode() << "." << std::endl;
-    qApp->exit(exitStatus == SshRemoteProcess::ExitedNormally && m_shell->exitCode() == 0
+    qApp->exit(exitStatus == SshRemoteProcess::NormalExit && m_shell->exitCode() == 0
         ? EXIT_SUCCESS : EXIT_FAILURE);
 }