Analyzer: Merge Valgrind process classes

Change-Id: Ic2ef2304fb5524d07858052806124f6b02ca4dcb
Reviewed-by: hjk <hjk121@nokiamail.com>

src/plugins/valgrind/callgrind/callgrindcontroller.cpp

@@ -99,10 +99,10 @@ void CallgrindController::run(Option option)
     }
     QTC_ASSERT(m_valgrindProc, return);
 
-    if (RemoteValgrindProcess *remote = qobject_cast<RemoteValgrindProcess *>(m_valgrindProc))
+    QSsh::SshConnection *connection = m_valgrindProc->connection();
-        m_process = new RemoteValgrindProcess(remote->connection(), this);
+    m_process = new ValgrindProcess(m_valgrindProc->isLocal(),
-    else
+                connection ? connection->connectionParameters() : QSsh::SshConnectionParameters(),
-        m_process = new LocalValgrindProcess(this);
+                connection, this);
 
     connect(m_process, SIGNAL(finished(int,QProcess::ExitStatus)),
             SLOT(processFinished(int,QProcess::ExitStatus)));
@@ -203,10 +203,10 @@ void CallgrindController::getLocalDataFile()
     // first, set the to-be-parsed file to callgrind.out.PID
     QString fileName = workingDir.isEmpty() ? baseFileName : (workingDir + QDir::separator() + baseFileName);
 
-    if (RemoteValgrindProcess *remote = qobject_cast<RemoteValgrindProcess *>(m_valgrindProc)) {
+    if (!m_valgrindProc->isLocal()) {
         ///TODO: error handling
         emit statusMessage(tr("Downloading remote profile data..."));
-        m_ssh = remote->connection();
+        m_ssh = m_valgrindProc->connection();
         // if there are files like callgrind.out.PID.NUM, set it to the most recent one of those
         QString cmd = QString::fromLatin1("ls -t %1* | head -n 1").arg(fileName);
         m_findRemoteFile = m_ssh->createRemoteProcess(cmd.toUtf8());

src/plugins/valgrind/valgrindprocess.cpp

@@ -42,191 +42,217 @@
 
 namespace Valgrind {
 
-ValgrindProcess::ValgrindProcess(QObject *parent)
+ValgrindProcess::ValgrindProcess(bool isLocal, const QSsh::SshConnectionParameters &sshParams,
-    : QObject(parent)
+                                 QSsh::SshConnection *connection, QObject *parent)
+    : QObject(parent), m_isLocal(isLocal)
 {
+    m_remote.m_params = sshParams;
+    m_remote.m_connection = connection;
+    m_remote.m_error = QProcess::UnknownError;
+    m_pid = 0;
 }
 
-////////////////////////
+void ValgrindProcess::setProcessChannelMode(QProcess::ProcessChannelMode mode)
-
-LocalValgrindProcess::LocalValgrindProcess(QObject *parent)
-: ValgrindProcess(parent)
 {
-    connect(&m_process, SIGNAL(finished(int,QProcess::ExitStatus)),
+    if (isLocal())
-            this, SIGNAL(finished(int,QProcess::ExitStatus)));
+        m_localProcess.setProcessChannelMode(mode);
-    connect(&m_process, SIGNAL(started()),
+    ///TODO: remote support this by handling the mode internally
-            this, SIGNAL(started()));
-    connect(&m_process, SIGNAL(error(QProcess::ProcessError)),
-            this, SIGNAL(error(QProcess::ProcessError)));
-    connect(&m_process, SIGNAL(readyReadStandardError()),
-            this, SLOT(readyReadStandardError()));
-    connect(&m_process, SIGNAL(readyReadStandardOutput()),
-            this, SLOT(readyReadStandardOutput()));
 }
 
-void LocalValgrindProcess::setProcessChannelMode(QProcess::ProcessChannelMode mode)
+void ValgrindProcess::setWorkingDirectory(const QString &path)
 {
-    m_process.setProcessChannelMode(mode);
+    if (isLocal())
+        m_localProcess.setWorkingDirectory(path);
+    else
+        m_remote.m_workingDir = path;
 }
 
-void LocalValgrindProcess::setWorkingDirectory(const QString &path)
+QString ValgrindProcess::workingDirectory() const
 {
-    m_process.setWorkingDirectory(path);
+    if (isLocal())
+        return m_localProcess.workingDirectory();
+    else
+        return m_remote.m_workingDir;
 }
 
-QString LocalValgrindProcess::workingDirectory() const
+bool ValgrindProcess::isRunning() const
 {
-    return m_process.workingDirectory();
+    if (isLocal())
+        return m_localProcess.state() != QProcess::NotRunning;
+    else
+        return m_remote.m_process && m_remote.m_process->isRunning();
 }
 
-bool LocalValgrindProcess::isRunning() const
+void ValgrindProcess::setEnvironment(const Utils::Environment &environment)
 {
-    return m_process.state() != QProcess::NotRunning;
+    if (isLocal())
+        m_localProcess.setEnvironment(environment);
+    ///TODO: remote anything that should/could be done here?
 }
 
-void LocalValgrindProcess::setEnvironment(const Utils::Environment &environment)
+void ValgrindProcess::close()
 {
-    m_process.setEnvironment(environment);
+    if (isLocal()) {
+        m_localProcess.terminate();
+    } else {
+        QTC_ASSERT(m_remote.m_connection->state() == QSsh::SshConnection::Connected, return);
+        if (m_remote.m_process) {
+            if (m_pid) {
+                const QString killTemplate = QString::fromLatin1("kill -%2 %1" // kill
+                                                    ).arg(m_pid);
+
+                const QString niceKill = killTemplate.arg(QLatin1String("SIGTERM"));
+                const QString brutalKill = killTemplate.arg(QLatin1String("SIGKILL"));
+                const QString remoteCall = niceKill + QLatin1String("; sleep 1; ") + brutalKill;
+
+                QSsh::SshRemoteProcess::Ptr cleanup = m_remote.m_connection->createRemoteProcess(remoteCall.toUtf8());
+                cleanup->start();
+            }
+        }
+    }
 }
 
-void LocalValgrindProcess::close()
+void ValgrindProcess::run(const QString &valgrindExecutable, const QStringList &valgrindArguments,
-{
-    m_process.terminate();
-}
-
-void LocalValgrindProcess::run(const QString &valgrindExecutable, const QStringList &valgrindArguments,
                                 const QString &debuggeeExecutable, const QString &debuggeeArguments)
 {
-    QString arguments;
+    Utils::QtcProcess::addArgs(&m_arguments, valgrindArguments);
-    Utils::QtcProcess::addArgs(&arguments, valgrindArguments);
+    Utils::QtcProcess::addArg(&m_arguments, debuggeeExecutable);
+    Utils::QtcProcess::addArgs(&m_arguments, debuggeeArguments);
 
-    Utils::QtcProcess::addArg(&arguments, debuggeeExecutable);
+    if (isLocal()) {
-    Utils::QtcProcess::addArgs(&arguments, debuggeeArguments);
+        connect(&m_localProcess, SIGNAL(finished(int,QProcess::ExitStatus)),
+                this, SIGNAL(finished(int,QProcess::ExitStatus)));
+        connect(&m_localProcess, SIGNAL(started()),
+                this, SIGNAL(started()));
+        connect(&m_localProcess, SIGNAL(error(QProcess::ProcessError)),
+                this, SIGNAL(error(QProcess::ProcessError)));
+        connect(&m_localProcess, SIGNAL(readyReadStandardError()),
+                this, SLOT(handleReadyReadStandardError()));
+        connect(&m_localProcess, SIGNAL(readyReadStandardOutput()),
+                this, SLOT(handleReadyReadStandardOutput()));
 
-    m_process.setCommand(valgrindExecutable, arguments);
+        m_localProcess.setCommand(valgrindExecutable, m_arguments);
-    m_process.start();
+        m_localProcess.start();
-    m_process.waitForStarted();
+        m_localProcess.waitForStarted();
-#ifdef Q_OS_WIN
+    #ifdef Q_OS_WIN
-    m_pid = m_process.pid()->dwProcessId;
+        m_pid = m_process.pid()->dwProcessId;
-#else
+    #else
-    m_pid = m_process.pid();
+        m_pid = m_localProcess.pid();
-#endif
+    #endif
+    } else {
+        m_remote.m_valgrindExe = valgrindExecutable;
+        m_remote.m_debuggee = debuggeeExecutable;
+
+        // connect to host and wait for connection
+        if (!m_remote.m_connection)
+            m_remote.m_connection = new QSsh::SshConnection(m_remote.m_params, this);
+
+        if (m_remote.m_connection->state() != QSsh::SshConnection::Connected) {
+            connect(m_remote.m_connection, SIGNAL(connected()), this, SLOT(connected()));
+            connect(m_remote.m_connection, SIGNAL(error(QSsh::SshError)),
+                    this, SLOT(handelError(QSsh::SshError)));
+            if (m_remote.m_connection->state() == QSsh::SshConnection::Unconnected)
+                m_remote.m_connection->connectToHost();
+        } else {
+            connected();
+        }
+    }
 }
 
-QString LocalValgrindProcess::errorString() const
+QString ValgrindProcess::errorString() const
 {
-    return m_process.errorString();
+    if (isLocal())
+        return m_localProcess.errorString();
+    else
+        return m_remote.m_errorString;
 }
 
-QProcess::ProcessError LocalValgrindProcess::error() const
+QProcess::ProcessError ValgrindProcess::error() const
 {
-    return m_process.error();
+    if (isLocal())
+        return m_localProcess.error();
+    else
+        return m_remote.m_error;
 }
 
-qint64 LocalValgrindProcess::pid() const
+void ValgrindProcess::handleError(QSsh::SshError error)
+{
+    if (isLocal()) {
+    } else {
+        switch (error) {
+            case QSsh::SshTimeoutError:
+                m_remote.m_error = QProcess::Timedout;
+                break;
+            default:
+                m_remote.m_error = QProcess::FailedToStart;
+                break;
+        }
+    }
+    m_remote.m_errorString = m_remote.m_connection->errorString();
+    emit this->error(m_remote.m_error);
+}
+
+qint64 ValgrindProcess::pid() const
 {
     return m_pid;
 }
 
-void LocalValgrindProcess::readyReadStandardError()
+void ValgrindProcess::handleReadyReadStandardError()
 {
-    const QByteArray b = m_process.readAllStandardError();
+    QByteArray b;
+    if (isLocal())
+        b = m_localProcess.readAllStandardError();
+    else
+        b = m_remote.m_process->readAllStandardError();
     if (!b.isEmpty())
         emit processOutput(b, Utils::StdErrFormat);
 }
 
-void LocalValgrindProcess::readyReadStandardOutput()
+void ValgrindProcess::handleReadyReadStandardOutput()
 {
-    const QByteArray b = m_process.readAllStandardOutput();
+    QByteArray b;
+    if (isLocal())
+        b = m_localProcess.readAllStandardOutput();
+    else
+        b = m_remote.m_process->readAllStandardOutput();
     if (!b.isEmpty())
         emit processOutput(b, Utils::StdOutFormat);
 }
 
-////////////////////////
+/// Remote
-
+void ValgrindProcess::connected()
-RemoteValgrindProcess::RemoteValgrindProcess(const QSsh::SshConnectionParameters &sshParams,
-                                             QObject *parent)
-    : ValgrindProcess(parent)
-    , m_params(sshParams)
-    , m_connection(0)
-    , m_error(QProcess::UnknownError)
-    , m_pid(0)
-{}
-
-RemoteValgrindProcess::RemoteValgrindProcess(QSsh::SshConnection *connection, QObject *parent)
-    : ValgrindProcess(parent)
-    , m_params(connection->connectionParameters())
-    , m_connection(connection)
-    , m_error(QProcess::UnknownError)
-    , m_pid(0)
-{}
-
-RemoteValgrindProcess::~RemoteValgrindProcess()
 {
-}
+    QTC_ASSERT(m_remote.m_connection->state() == QSsh::SshConnection::Connected, return);
-
-bool RemoteValgrindProcess::isRunning() const
-{
-    return m_process && m_process->isRunning();
-}
-
-void RemoteValgrindProcess::run(const QString &valgrindExecutable, const QStringList &valgrindArguments,
-                                const QString &debuggeeExecutable, const QString &debuggeeArguments)
-{
-    m_valgrindExe = valgrindExecutable;
-    m_debuggee = debuggeeExecutable;
-    m_debuggeeArgs = debuggeeArguments;
-    m_valgrindArgs = valgrindArguments;
-
-    // connect to host and wait for connection
-    if (!m_connection)
-        m_connection = new QSsh::SshConnection(m_params, this);
-
-    if (m_connection->state() != QSsh::SshConnection::Connected) {
-        connect(m_connection, SIGNAL(connected()), this, SLOT(connected()));
-        connect(m_connection, SIGNAL(error(QSsh::SshError)),
-                this, SLOT(error(QSsh::SshError)));
-        if (m_connection->state() == QSsh::SshConnection::Unconnected)
-            m_connection->connectToHost();
-    } else {
-        connected();
-    }
-}
-
-void RemoteValgrindProcess::connected()
-{
-    QTC_ASSERT(m_connection->state() == QSsh::SshConnection::Connected, return);
 
     // connected, run command
     QString cmd;
 
-    if (!m_workingDir.isEmpty())
+    if (!m_remote.m_workingDir.isEmpty())
-        cmd += QString::fromLatin1("cd '%1' && ").arg(m_workingDir);
+        cmd += QString::fromLatin1("cd '%1' && ").arg(m_remote.m_workingDir);
 
-    QString arguments;
+    cmd += m_remote.m_valgrindExe + QLatin1Char(' ') + m_arguments;
-    Utils::QtcProcess::addArgs(&arguments, m_valgrindArgs);
-    Utils::QtcProcess::addArg(&arguments, m_debuggee);
-    Utils::QtcProcess::addArgs(&arguments, m_debuggeeArgs);
-    cmd += m_valgrindExe + QLatin1Char(' ') + arguments;
 
-    m_process = m_connection->createRemoteProcess(cmd.toUtf8());
+    m_remote.m_process = m_remote.m_connection->createRemoteProcess(cmd.toUtf8());
-    connect(m_process.data(), SIGNAL(readyReadStandardError()), this, SLOT(standardError()));
+    connect(m_remote.m_process.data(), SIGNAL(readyReadStandardError()),
-    connect(m_process.data(), SIGNAL(readyReadStandardOutput()), this, SLOT(standardOutput()));
+            this, SLOT(handleReadyReadStandardError()));
-    connect(m_process.data(), SIGNAL(closed(int)),
+    connect(m_remote.m_process.data(), SIGNAL(readyReadStandardOutput()),
+            this, SLOT(handleReadyReadStandardOutput()));
+    connect(m_remote.m_process.data(), SIGNAL(closed(int)),
             this, SLOT(closed(int)));
-    connect(m_process.data(), SIGNAL(started()),
+    connect(m_remote.m_process.data(), SIGNAL(started()),
             this, SLOT(processStarted()));
-    m_process->start();
+    m_remote.m_process->start();
 }
 
-QSsh::SshConnection *RemoteValgrindProcess::connection() const
+
+QSsh::SshConnection *ValgrindProcess::connection() const
 {
-    return m_connection;
+    return m_remote.m_connection;
 }
 
-void RemoteValgrindProcess::processStarted()
+void ValgrindProcess::processStarted()
 {
-    QTC_ASSERT(m_connection->state() == QSsh::SshConnection::Connected, return);
+    QTC_ASSERT(m_remote.m_connection->state() == QSsh::SshConnection::Connected, return);
 
     // find out what PID our process has
 
@@ -237,7 +263,7 @@ void RemoteValgrindProcess::processStarted()
     // hence we need to do something more complex...
 
     // plain path to exe, m_valgrindExe contains e.g. env vars etc. pp.
-    const QString proc = m_valgrindExe.split(QLatin1Char(' ')).last();
+    const QString proc = m_remote.m_valgrindExe.split(QLatin1Char(' ')).last();
     // sleep required since otherwise we might only match "bash -c..."
     //  and not the actual valgrind run
     const QString cmd = QString::fromLatin1("sleep 1; ps ax" // list all processes with aliased name
@@ -245,22 +271,24 @@ void RemoteValgrindProcess::processStarted()
                                             " | tail -n 1" // limit to single process
                                             // we pick the last one, first would be "bash -c ..."
                                             " | awk '{print $1;}'" // get pid
-                                            ).arg(proc, QFileInfo(m_debuggee).fileName());
+                                            ).arg(proc, QFileInfo(m_remote.m_debuggee).fileName());
 
-    m_findPID = m_connection->createRemoteProcess(cmd.toUtf8());
+    m_remote.m_findPID = m_remote.m_connection->createRemoteProcess(cmd.toUtf8());
-    connect(m_findPID.data(), SIGNAL(readyReadStandardError()), this, SLOT(standardError()));
+    connect(m_remote.m_findPID.data(), SIGNAL(readyReadStandardError()),
-    connect(m_findPID.data(), SIGNAL(readyReadStandardOutput()), SLOT(findPIDOutputReceived()));
+            this, SLOT(handleReadyReadStandardError()));
-    m_findPID->start();
+    connect(m_remote.m_findPID.data(), SIGNAL(readyReadStandardOutput()),
+            this, SLOT(findPIDOutputReceived()));
+    m_remote.m_findPID->start();
 }
 
-void RemoteValgrindProcess::findPIDOutputReceived()
+void ValgrindProcess::findPIDOutputReceived()
 {
     bool ok;
-    m_pid = m_findPID->readAllStandardOutput().trimmed().toLongLong(&ok);
+    m_pid = m_remote.m_findPID->readAllStandardOutput().trimmed().toLongLong(&ok);
     if (!ok) {
         m_pid = 0;
-        m_errorString = tr("Could not determine remote PID.");
+        m_remote.m_errorString = tr("Could not determine remote PID.");
-        m_error = QProcess::FailedToStart;
+        m_remote.m_error = QProcess::FailedToStart;
         emit ValgrindProcess::error(QProcess::FailedToStart);
         close();
     } else {
@@ -268,99 +296,23 @@ void RemoteValgrindProcess::findPIDOutputReceived()
     }
 }
 
-void RemoteValgrindProcess::standardOutput()
+
+///////////
+
+void ValgrindProcess::closed(int status)
 {
-    emit processOutput(m_process->readAllStandardOutput(), Utils::StdOutFormat);
+    QTC_ASSERT(m_remote.m_process, return);
-}
 
-void RemoteValgrindProcess::standardError()
+    m_remote.m_errorString = m_remote.m_process->errorString();
-{
-    emit processOutput(m_process->readAllStandardError(), Utils::StdErrFormat);
-}
-
-void RemoteValgrindProcess::error(QSsh::SshError error)
-{
-    switch (error) {
-        case QSsh::SshTimeoutError:
-            m_error = QProcess::Timedout;
-            break;
-        default:
-            m_error = QProcess::FailedToStart;
-            break;
-    }
-    m_errorString = m_connection->errorString();
-    emit ValgrindProcess::error(m_error);
-}
-
-void RemoteValgrindProcess::close()
-{
-    QTC_ASSERT(m_connection->state() == QSsh::SshConnection::Connected, return);
-    if (m_process) {
-        if (m_pid) {
-            const QString killTemplate = QString::fromLatin1("kill -%2 %1" // kill
-                                                ).arg(m_pid);
-
-            const QString niceKill = killTemplate.arg(QLatin1String("SIGTERM"));
-            const QString brutalKill = killTemplate.arg(QLatin1String("SIGKILL"));
-            const QString remoteCall = niceKill + QLatin1String("; sleep 1; ") + brutalKill;
-
-            QSsh::SshRemoteProcess::Ptr cleanup = m_connection->createRemoteProcess(remoteCall.toUtf8());
-            cleanup->start();
-        }
-    }
-}
-
-void RemoteValgrindProcess::closed(int status)
-{
-    QTC_ASSERT(m_process, return);
-
-    m_errorString = m_process->errorString();
     if (status == QSsh::SshRemoteProcess::FailedToStart) {
-        m_error = QProcess::FailedToStart;
+        m_remote.m_error = QProcess::FailedToStart;
         emit ValgrindProcess::error(QProcess::FailedToStart);
     } else if (status == QSsh::SshRemoteProcess::NormalExit) {
-        emit finished(m_process->exitCode(), QProcess::NormalExit);
+        emit finished(m_remote.m_process->exitCode(), QProcess::NormalExit);
     } else if (status == QSsh::SshRemoteProcess::CrashExit) {
-        m_error = QProcess::Crashed;
+        m_remote.m_error = QProcess::Crashed;
-        emit finished(m_process->exitCode(), QProcess::CrashExit);
+        emit finished(m_remote.m_process->exitCode(), QProcess::CrashExit);
     }
 }
 
-QString RemoteValgrindProcess::errorString() const
-{
-    return m_errorString;
-}
-
-QProcess::ProcessError RemoteValgrindProcess::error() const
-{
-    return m_error;
-}
-
-void RemoteValgrindProcess::setEnvironment(const Utils::Environment &environment)
-{
-    Q_UNUSED(environment);
-    ///TODO: anything that should/could be done here?
-}
-
-void RemoteValgrindProcess::setProcessChannelMode(QProcess::ProcessChannelMode mode)
-{
-    Q_UNUSED(mode);
-    ///TODO: support this by handling the mode internally
-}
-
-void RemoteValgrindProcess::setWorkingDirectory(const QString &path)
-{
-    m_workingDir = path;
-}
-
-QString RemoteValgrindProcess::workingDirectory() const
-{
-    return m_workingDir;
-}
-
-qint64 RemoteValgrindProcess::pid() const
-{
-    return m_pid;
-}
-
 } // namespace Valgrind

src/plugins/valgrind/valgrindprocess.h

@@ -38,130 +38,74 @@
 
 namespace Valgrind {
 
+struct Remote {
+    QSsh::SshConnectionParameters m_params;
+    QSsh::SshConnection *m_connection;
+    QSsh::SshRemoteProcess::Ptr m_process;
+    QString m_workingDir;
+    QString m_valgrindExe;
+    QString m_debuggee;
+    QString m_errorString;
+    QProcess::ProcessError m_error;
+    QSsh::SshRemoteProcess::Ptr m_findPID;
+};
+
 /**
- * Abstract process that can be subclassed to supply local and remote valgrind runs
+ * Process for supplying local and remote valgrind runs
  */
 class ValgrindProcess : public QObject
 {
     Q_OBJECT
 
 public:
-    explicit ValgrindProcess(QObject *parent = 0);
+    ValgrindProcess(bool isLocal, const QSsh::SshConnectionParameters &sshParams,
+                    QSsh::SshConnection *connection = 0, QObject *parent = 0);
 
-    virtual bool isRunning() const = 0;
+    bool isRunning() const;
 
-    virtual void run(const QString &valgrindExecutable, const QStringList &valgrindArguments,
+    void run(const QString &valgrindExecutable, const QStringList &valgrindArguments,
-                     const QString &debuggeeExecutable, const QString &debuggeeArguments) = 0;
+             const QString &debuggeeExecutable, const QString &debuggeeArguments);
-    virtual void close() = 0;
+    void close();
 
-    virtual QString errorString() const = 0;
+    QString errorString() const;
-    virtual QProcess::ProcessError error() const = 0;
+    QProcess::ProcessError error() const;
 
-    virtual void setProcessChannelMode(QProcess::ProcessChannelMode mode) = 0;
+    void setProcessChannelMode(QProcess::ProcessChannelMode mode);
-    virtual void setWorkingDirectory(const QString &path) = 0;
+    void setWorkingDirectory(const QString &path);
-    virtual QString workingDirectory() const = 0;
+    QString workingDirectory() const;
-    virtual void setEnvironment(const Utils::Environment &environment) = 0;
+    void setEnvironment(const Utils::Environment &environment);
 
-    virtual qint64 pid() const = 0;
+    qint64 pid() const;
+    QSsh::SshConnection *connection() const;
+    bool isLocal() const { return m_isLocal; }
 
 signals:
     void started();
     void finished(int, QProcess::ExitStatus);
     void error(QProcess::ProcessError);
     void processOutput(const QByteArray &, Utils::OutputFormat format);
-};
-
-/**
- * Run valgrind on the local machine
- */
-class LocalValgrindProcess : public ValgrindProcess
-{
-    Q_OBJECT
-
-public:
-    explicit LocalValgrindProcess(QObject *parent = 0);
-
-    virtual bool isRunning() const;
-
-    virtual void run(const QString &valgrindExecutable, const QStringList &valgrindArguments,
-                     const QString &debuggeeExecutable, const QString &debuggeeArguments);
-    virtual void close();
-
-    virtual QString errorString() const;
-    QProcess::ProcessError error() const;
-
-    virtual void setProcessChannelMode(QProcess::ProcessChannelMode mode);
-    virtual void setWorkingDirectory(const QString &path);
-    virtual QString workingDirectory() const;
-    virtual void setEnvironment(const Utils::Environment &environment);
-
-    virtual qint64 pid() const;
 
 private slots:
-    void readyReadStandardError();
+    void handleReadyReadStandardError();
-    void readyReadStandardOutput();
+    void handleReadyReadStandardOutput();
+    void handleError(QSsh::SshError);
 
-private:
-    Utils::QtcProcess m_process;
-    qint64 m_pid;
-};
-
-/**
- * Run valgrind on a remote machine via SSH
- */
-class RemoteValgrindProcess : public ValgrindProcess
-{
-    Q_OBJECT
-
-public:
-    explicit RemoteValgrindProcess(const QSsh::SshConnectionParameters &sshParams,
-                                   QObject *parent = 0);
-    explicit RemoteValgrindProcess(QSsh::SshConnection *connection,
-                                   QObject *parent = 0);
-    ~RemoteValgrindProcess();
-
-    virtual bool isRunning() const;
-
-    virtual void run(const QString &valgrindExecutable, const QStringList &valgrindArguments,
-                     const QString &debuggeeExecutable, const QString &debuggeeArguments);
-    virtual void close();
-
-    virtual QString errorString() const;
-    QProcess::ProcessError error() const;
-
-    virtual void setProcessChannelMode(QProcess::ProcessChannelMode mode);
-    virtual void setWorkingDirectory(const QString &path);
-    virtual QString workingDirectory() const;
-    virtual void setEnvironment(const Utils::Environment &environment);
-
-    virtual qint64 pid() const;
-
-    QSsh::SshConnection *connection() const;
-
-private slots:
     void closed(int);
     void connected();
-    void error(QSsh::SshError error);
     void processStarted();
     void findPIDOutputReceived();
-    void standardOutput();
-    void standardError();
 
 private:
-    QSsh::SshConnectionParameters m_params;
+    Utils::QtcProcess m_localProcess;
-    QSsh::SshConnection *m_connection;
-    QSsh::SshRemoteProcess::Ptr m_process;
-    QString m_workingDir;
-    QString m_valgrindExe;
-    QStringList m_valgrindArgs;
-    QString m_debuggee;
-    QString m_debuggeeArgs;
-    QString m_errorString;
-    QProcess::ProcessError m_error;
     qint64 m_pid;
-    QSsh::SshRemoteProcess::Ptr m_findPID;
+
+    Remote m_remote;
+    QString m_arguments;
+    bool m_isLocal;
 };
 
+
+
 } // namespace Valgrind
 
 #endif // VALGRINDPROCESS_H

src/plugins/valgrind/valgrindrunner.cpp

@@ -216,10 +216,7 @@ void ValgrindRunner::waitForFinished() const
 
 bool ValgrindRunner::start()
 {
-    if (d->startMode == Analyzer::StartLocal)
+    d->run(new ValgrindProcess(d->startMode == Analyzer::StartLocal, d->connParams, 0, this));
-        d->run(new LocalValgrindProcess(this));
-    else if (d->startMode == Analyzer::StartRemote)
-        d->run(new RemoteValgrindProcess(d->connParams, this));
     return true;
 }