Analyzer: Merge IAnalyzerEngine and AnalyzerRunControl

Change-Id: I74edaef59600a44924d2692c1ebc7f98d8581115
Reviewed-by: Christiaan Janssen <christiaan.janssen@digia.com>

src/plugins/valgrind/callgrindengine.cpp

@@ -42,9 +42,9 @@ using namespace Analyzer;
 using namespace Valgrind;
 using namespace Valgrind::Internal;
 
-CallgrindEngine::CallgrindEngine(const AnalyzerStartParameters &sp,
+CallgrindRunControl::CallgrindRunControl(const AnalyzerStartParameters &sp,
          ProjectExplorer::RunConfiguration *runConfiguration)
-    : ValgrindEngine(sp, runConfiguration)
+    : ValgrindRunControl(sp, runConfiguration)
     , m_markAsPaused(false)
 {
     connect(&m_runner, SIGNAL(finished()), this, SLOT(slotFinished()));
@@ -55,12 +55,12 @@ CallgrindEngine::CallgrindEngine(const AnalyzerStartParameters &sp,
     m_progress->setProgressRange(0, 2);
 }
 
-void CallgrindEngine::showStatusMessage(const QString &msg)
+void CallgrindRunControl::showStatusMessage(const QString &msg)
 {
     AnalyzerManager::showStatusMessage(msg);
 }
 
-QStringList CallgrindEngine::toolArguments() const
+QStringList CallgrindRunControl::toolArguments() const
 {
     QStringList arguments;
 
@@ -89,28 +89,28 @@ QStringList CallgrindEngine::toolArguments() const
     return arguments;
 }
 
-QString CallgrindEngine::progressTitle() const
+QString CallgrindRunControl::progressTitle() const
 {
     return tr("Profiling");
 }
 
-Valgrind::ValgrindRunner * CallgrindEngine::runner()
+Valgrind::ValgrindRunner * CallgrindRunControl::runner()
 {
     return &m_runner;
 }
 
-bool CallgrindEngine::start()
+bool CallgrindRunControl::startEngine()
 {
-    emit outputReceived(tr("Profiling %1\n").arg(executable()), Utils::NormalMessageFormat);
-    return ValgrindEngine::start();
+    appendMessage(tr("Profiling %1\n").arg(executable()), Utils::NormalMessageFormat);
+    return ValgrindRunControl::startEngine();
 }
 
-void CallgrindEngine::dump()
+void CallgrindRunControl::dump()
 {
     m_runner.controller()->run(Valgrind::Callgrind::CallgrindController::Dump);
 }
 
-void CallgrindEngine::setPaused(bool paused)
+void CallgrindRunControl::setPaused(bool paused)
 {
     if (m_markAsPaused == paused)
         return;
@@ -126,7 +126,7 @@ void CallgrindEngine::setPaused(bool paused)
     }
 }
 
-void CallgrindEngine::setToggleCollectFunction(const QString &toggleCollectFunction)
+void CallgrindRunControl::setToggleCollectFunction(const QString &toggleCollectFunction)
 {
     if (toggleCollectFunction.isEmpty())
         return;
@@ -134,32 +134,32 @@ void CallgrindEngine::setToggleCollectFunction(const QString &toggleCollectFunct
     m_argumentForToggleCollect = QLatin1String("--toggle-collect=") + toggleCollectFunction;
 }
 
-void CallgrindEngine::reset()
+void CallgrindRunControl::reset()
 {
     m_runner.controller()->run(Valgrind::Callgrind::CallgrindController::ResetEventCounters);
 }
 
-void CallgrindEngine::pause()
+void CallgrindRunControl::pause()
 {
     m_runner.controller()->run(Valgrind::Callgrind::CallgrindController::Pause);
 }
 
-void CallgrindEngine::unpause()
+void CallgrindRunControl::unpause()
 {
     m_runner.controller()->run(Valgrind::Callgrind::CallgrindController::UnPause);
 }
 
-Valgrind::Callgrind::ParseData *CallgrindEngine::takeParserData()
+Valgrind::Callgrind::ParseData *CallgrindRunControl::takeParserData()
 {
     return m_runner.parser()->takeData();
 }
 
-void CallgrindEngine::slotFinished()
+void CallgrindRunControl::slotFinished()
 {
     emit parserDataReady(this);
 }
 
-void CallgrindEngine::slotStarted()
+void CallgrindRunControl::slotStarted()
 {
     m_progress->setProgressValue(1);;
 }

src/plugins/valgrind/callgrindengine.h

@@ -38,15 +38,15 @@
 namespace Valgrind {
 namespace Internal {
 
-class CallgrindEngine : public Valgrind::Internal::ValgrindEngine
+class CallgrindRunControl : public ValgrindRunControl
 {
     Q_OBJECT
 
 public:
-    CallgrindEngine(const Analyzer::AnalyzerStartParameters &sp,
+    CallgrindRunControl(const Analyzer::AnalyzerStartParameters &sp,
         ProjectExplorer::RunConfiguration *runConfiguration);
 
-    bool start();
+    bool startEngine();
 
     Valgrind::Callgrind::ParseData *takeParserData();
 
@@ -71,7 +71,7 @@ protected:
     virtual Valgrind::ValgrindRunner *runner();
 
 signals:
-    void parserDataReady(CallgrindEngine *engine);
+    void parserDataReady(CallgrindRunControl *engine);
 
 private slots:
     void slotFinished();

src/plugins/valgrind/callgrindtool.cpp

@@ -118,7 +118,7 @@ public:
     void doClear(bool clearParseData);
     void updateEventCombo();
 
-    IAnalyzerEngine *createEngine(const AnalyzerStartParameters &sp,
+    AnalyzerRunControl *createRunControl(const AnalyzerStartParameters &sp,
         ProjectExplorer::RunConfiguration *runConfiguration = 0);
 
 signals:
@@ -163,8 +163,8 @@ public slots:
     void visualisationFunctionSelected(const Valgrind::Callgrind::Function *function);
     void showParserResults(const Valgrind::Callgrind::ParseData *data);
 
-    void takeParserData(CallgrindEngine *engine);
-    void engineStarting(const Analyzer::IAnalyzerEngine *);
+    void takeParserData(CallgrindRunControl *rc);
+    void engineStarting(const Analyzer::AnalyzerRunControl *);
     void engineFinished();
 
     void editorOpened(Core::IEditor *);
@@ -569,38 +569,38 @@ void CallgrindTool::extensionsInitialized()
     }
 }
 
-IAnalyzerEngine *CallgrindTool::createEngine(const AnalyzerStartParameters &sp,
+AnalyzerRunControl *CallgrindTool::createRunControl(const AnalyzerStartParameters &sp,
     RunConfiguration *runConfiguration)
 {
-    return d->createEngine(sp, runConfiguration);
+    return d->createRunControl(sp, runConfiguration);
 }
 
-IAnalyzerEngine *CallgrindToolPrivate::createEngine(const AnalyzerStartParameters &sp,
+AnalyzerRunControl *CallgrindToolPrivate::createRunControl(const AnalyzerStartParameters &sp,
     RunConfiguration *runConfiguration)
 {
-    CallgrindEngine *engine = new CallgrindEngine(sp, runConfiguration);
+    CallgrindRunControl *rc = new CallgrindRunControl(sp, runConfiguration);
 
-    connect(engine, SIGNAL(parserDataReady(CallgrindEngine*)),
-            SLOT(takeParserData(CallgrindEngine*)));
-    connect(engine, SIGNAL(starting(const Analyzer::IAnalyzerEngine*)),
-            SLOT(engineStarting(const Analyzer::IAnalyzerEngine*)));
-    connect(engine, SIGNAL(finished()),
+    connect(rc, SIGNAL(parserDataReady(CallgrindRunControl*)),
+            SLOT(takeParserData(CallgrindRunControl*)));
+    connect(rc, SIGNAL(starting(const Analyzer::AnalyzerRunControl*)),
+            SLOT(engineStarting(const Analyzer::AnalyzerRunControl*)));
+    connect(rc, SIGNAL(finished()),
             SLOT(engineFinished()));
 
-    connect(this, SIGNAL(dumpRequested()), engine, SLOT(dump()));
-    connect(this, SIGNAL(resetRequested()), engine, SLOT(reset()));
-    connect(this, SIGNAL(pauseToggled(bool)), engine, SLOT(setPaused(bool)));
+    connect(this, SIGNAL(dumpRequested()), rc, SLOT(dump()));
+    connect(this, SIGNAL(resetRequested()), rc, SLOT(reset()));
+    connect(this, SIGNAL(pauseToggled(bool)), rc, SLOT(setPaused(bool)));
 
-    // initialize engine
-    engine->setPaused(m_pauseAction->isChecked());
+    // initialize run control
+    rc->setPaused(m_pauseAction->isChecked());
 
     // we may want to toggle collect for one function only in this run
-    engine->setToggleCollectFunction(m_toggleCollectFunction);
+    rc->setToggleCollectFunction(m_toggleCollectFunction);
     m_toggleCollectFunction.clear();
 
     AnalyzerManager::showStatusMessage(AnalyzerManager::msgToolStarted(q->displayName()));
 
-    QTC_ASSERT(m_visualisation, return engine);
+    QTC_ASSERT(m_visualisation, return rc);
 
     // apply project settings
     if (runConfiguration) {
@@ -612,7 +612,7 @@ IAnalyzerEngine *CallgrindToolPrivate::createEngine(const AnalyzerStartParameter
             }
         }
     }
-    return engine;
+    return rc;
 }
 
 void CallgrindTool::startTool(StartMode mode)
@@ -856,7 +856,7 @@ void CallgrindToolPrivate::clearTextMarks()
     m_textMarks.clear();
 }
 
-void CallgrindToolPrivate::engineStarting(const Analyzer::IAnalyzerEngine *)
+void CallgrindToolPrivate::engineStarting(const Analyzer::AnalyzerRunControl *)
 {
     // enable/disable actions
     m_resetAction->setEnabled(true);
@@ -964,9 +964,9 @@ void CallgrindToolPrivate::slotRequestDump()
     dumpRequested();
 }
 
-void CallgrindToolPrivate::takeParserData(CallgrindEngine *engine)
+void CallgrindToolPrivate::takeParserData(CallgrindRunControl *rc)
 {
-    ParseData *data = engine->takeParserData();
+    ParseData *data = rc->takeParserData();
     showParserResults(data);
 
     if (!data)

src/plugins/valgrind/callgrindtool.h

@@ -54,7 +54,7 @@ public:
 
     void extensionsInitialized();
 
-    Analyzer::IAnalyzerEngine *createEngine(const Analyzer::AnalyzerStartParameters &sp,
+    Analyzer::AnalyzerRunControl *createRunControl(const Analyzer::AnalyzerStartParameters &sp,
         ProjectExplorer::RunConfiguration *runConfiguration = 0);
     QWidget *createWidgets();
 

src/plugins/valgrind/memcheckengine.cpp

@@ -34,20 +34,24 @@
 
 #include <analyzerbase/analyzersettings.h>
 
+#include <projectexplorer/projectexplorer.h>
+#include <projectexplorer/taskhub.h>
+
 #include <valgrind/xmlprotocol/error.h>
 #include <valgrind/xmlprotocol/status.h>
 
 #include <utils/qtcassert.h>
 
 using namespace Analyzer;
+using namespace ProjectExplorer;
 using namespace Valgrind::XmlProtocol;
 
 namespace Valgrind {
 namespace Internal {
 
-MemcheckEngine::MemcheckEngine(const AnalyzerStartParameters &sp,
+MemcheckRunControl::MemcheckRunControl(const AnalyzerStartParameters &sp,
         ProjectExplorer::RunConfiguration *runConfiguration)
-    : ValgrindEngine(sp, runConfiguration)
+    : ValgrindRunControl(sp, runConfiguration)
 {
     connect(&m_parser, SIGNAL(error(Valgrind::XmlProtocol::Error)),
             SIGNAL(parserError(Valgrind::XmlProtocol::Error)));
@@ -61,33 +65,36 @@ MemcheckEngine::MemcheckEngine(const AnalyzerStartParameters &sp,
     m_progress->setProgressRange(0, XmlProtocol::Status::Finished + 1);
 }
 
-QString MemcheckEngine::progressTitle() const
+QString MemcheckRunControl::progressTitle() const
 {
     return tr("Analyzing Memory");
 }
 
-Valgrind::ValgrindRunner *MemcheckEngine::runner()
+Valgrind::ValgrindRunner *MemcheckRunControl::runner()
 {
     return &m_runner;
 }
 
-bool MemcheckEngine::start()
+bool MemcheckRunControl::startEngine()
 {
     m_runner.setParser(&m_parser);
 
-    emit outputReceived(tr("Analyzing memory of %1\n").arg(executable()),
+    // Clear about-to-be-outdated tasks.
+    ProjectExplorerPlugin::instance()->taskHub()->clearTasks(Analyzer::Constants::ANALYZERTASK_ID);
+
+    appendMessage(tr("Analyzing memory of %1\n").arg(executable()),
                         Utils::NormalMessageFormat);
-    return ValgrindEngine::start();
+    return ValgrindRunControl::startEngine();
 }
 
-void MemcheckEngine::stop()
+void MemcheckRunControl::stopEngine()
 {
     disconnect(&m_parser, SIGNAL(internalError(QString)),
                this, SIGNAL(internalParserError(QString)));
-    ValgrindEngine::stop();
+    ValgrindRunControl::stopEngine();
 }
 
-QStringList MemcheckEngine::toolArguments() const
+QStringList MemcheckRunControl::toolArguments() const
 {
     QStringList arguments;
     arguments << QLatin1String("--gen-suppressions=all");
@@ -105,17 +112,17 @@ QStringList MemcheckEngine::toolArguments() const
     return arguments;
 }
 
-QStringList MemcheckEngine::suppressionFiles() const
+QStringList MemcheckRunControl::suppressionFiles() const
 {
     return m_settings->subConfig<ValgrindBaseSettings>()->suppressionFiles();
 }
 
-void MemcheckEngine::status(const Status &status)
+void MemcheckRunControl::status(const Status &status)
 {
     m_progress->setProgressValue(status.state() + 1);
 }
 
-void MemcheckEngine::receiveLogMessage(const QByteArray &b)
+void MemcheckRunControl::receiveLogMessage(const QByteArray &b)
 {
     QString error = QString::fromLocal8Bit(b);
     // workaround https://bugs.kde.org/show_bug.cgi?id=255888
@@ -126,7 +133,7 @@ void MemcheckEngine::receiveLogMessage(const QByteArray &b)
     if (error.isEmpty())
         return;
 
-    stop();
+    stopEngine();
 
     QString file;
     int line = -1;
@@ -138,7 +145,10 @@ void MemcheckEngine::receiveLogMessage(const QByteArray &b)
         line = suppressionError.cap(2).toInt();
     }
 
-    emit taskToBeAdded(ProjectExplorer::Task::Error, error, file, line);
+    TaskHub *hub = ProjectExplorerPlugin::instance()->taskHub();
+    hub->addTask(Task(Task::Error, error, Utils::FileName::fromUserInput(file), line,
+                      Analyzer::Constants::ANALYZERTASK_ID));
+    hub->requestPopup();
 }
 
 } // namespace Internal

src/plugins/valgrind/memcheckengine.h

@@ -39,16 +39,16 @@
 namespace Valgrind {
 namespace Internal {
 
-class MemcheckEngine : public ValgrindEngine
+class MemcheckRunControl : public ValgrindRunControl
 {
     Q_OBJECT
 
 public:
-    MemcheckEngine(const Analyzer::AnalyzerStartParameters &sp,
+    MemcheckRunControl(const Analyzer::AnalyzerStartParameters &sp,
         ProjectExplorer::RunConfiguration *runConfiguration);
 
-    bool start();
-    void stop();
+    bool startEngine();
+    void stopEngine();
 
     QStringList suppressionFiles() const;
 

src/plugins/valgrind/memchecktool.cpp

@@ -450,16 +450,16 @@ QWidget *MemcheckTool::createWidgets()
     return widget;
 }
 
-IAnalyzerEngine *MemcheckTool::createEngine(const AnalyzerStartParameters &sp,
+AnalyzerRunControl *MemcheckTool::createRunControl(const AnalyzerStartParameters &sp,
                                             RunConfiguration *runConfiguration)
 {
     m_frameFinder->setFiles(runConfiguration ? runConfiguration->target()
         ->project()->files(Project::AllFiles) : QStringList());
 
-    MemcheckEngine *engine = new MemcheckEngine(sp, runConfiguration);
+    MemcheckRunControl *engine = new MemcheckRunControl(sp, runConfiguration);
 
-    connect(engine, SIGNAL(starting(const Analyzer::IAnalyzerEngine*)),
-            this, SLOT(engineStarting(const Analyzer::IAnalyzerEngine*)));
+    connect(engine, SIGNAL(starting(const Analyzer::AnalyzerRunControl*)),
+            this, SLOT(engineStarting(const Analyzer::AnalyzerRunControl*)));
     connect(engine, SIGNAL(parserError(Valgrind::XmlProtocol::Error)),
             this, SLOT(parserError(Valgrind::XmlProtocol::Error)));
     connect(engine, SIGNAL(internalParserError(QString)),
@@ -474,7 +474,7 @@ void MemcheckTool::startTool(StartMode mode)
     ValgrindPlugin::startValgrindTool(this, mode);
 }
 
-void MemcheckTool::engineStarting(const IAnalyzerEngine *engine)
+void MemcheckTool::engineStarting(const AnalyzerRunControl *engine)
 {
     setBusyCursor(true);
     clearErrorView();
@@ -483,7 +483,7 @@ void MemcheckTool::engineStarting(const IAnalyzerEngine *engine)
     if (RunConfiguration *rc = engine->runConfiguration())
         dir = rc->target()->project()->projectDirectory() + QDir::separator();
 
-    const MemcheckEngine *mEngine = dynamic_cast<const MemcheckEngine *>(engine);
+    const MemcheckRunControl *mEngine = dynamic_cast<const MemcheckRunControl *>(engine);
     QTC_ASSERT(mEngine, return);
     const QString name = QFileInfo(mEngine->executable()).fileName();
 

src/plugins/valgrind/memchecktool.h

@@ -98,7 +98,7 @@ private slots:
     void settingsDestroyed(QObject *settings);
     void maybeActiveRunConfigurationChanged();
 
-    void engineStarting(const Analyzer::IAnalyzerEngine *engine);
+    void engineStarting(const Analyzer::AnalyzerRunControl *engine);
     void finished();
 
     void parserError(const Valgrind::XmlProtocol::Error &error);
@@ -112,7 +112,7 @@ private:
     QWidget *createWidgets();
     void setBusyCursor(bool busy);
 
-    Analyzer::IAnalyzerEngine *createEngine(const Analyzer::AnalyzerStartParameters &sp,
+    Analyzer::AnalyzerRunControl *createRunControl(const Analyzer::AnalyzerStartParameters &sp,
                                ProjectExplorer::RunConfiguration *runConfiguration = 0);
     void startTool(Analyzer::StartMode mode);
 

src/plugins/valgrind/valgrindengine.cpp

@@ -53,9 +53,9 @@ namespace Internal {
 
 const int progressMaximum  = 1000000;
 
-ValgrindEngine::ValgrindEngine(const AnalyzerStartParameters &sp,
+ValgrindRunControl::ValgrindRunControl(const AnalyzerStartParameters &sp,
         ProjectExplorer::RunConfiguration *runConfiguration)
-    : IAnalyzerEngine(sp, runConfiguration),
+    : AnalyzerRunControl(sp, runConfiguration),
       m_settings(0),
       m_progress(new QFutureInterface<void>()),
       m_progressWatcher(new QFutureWatcher<void>()),
@@ -73,12 +73,12 @@ ValgrindEngine::ValgrindEngine(const AnalyzerStartParameters &sp,
             this, SLOT(handleProgressFinished()));
 }
 
-ValgrindEngine::~ValgrindEngine()
+ValgrindRunControl::~ValgrindRunControl()
 {
     delete m_progress;
 }
 
-bool ValgrindEngine::start()
+bool ValgrindRunControl::startEngine()
 {
     emit starting(this);
 
@@ -123,32 +123,32 @@ bool ValgrindEngine::start()
     return true;
 }
 
-void ValgrindEngine::stop()
+void ValgrindRunControl::stopEngine()
 {
     m_isStopping = true;
     runner()->stop();
 }
 
-QString ValgrindEngine::executable() const
+QString ValgrindRunControl::executable() const
 {
     return startParameters().debuggee;
 }
 
-void ValgrindEngine::handleProgressCanceled()
+void ValgrindRunControl::handleProgressCanceled()
 {
     AnalyzerManager::stopTool();
     m_progress->reportCanceled();
     m_progress->reportFinished();
 }
 
-void ValgrindEngine::handleProgressFinished()
+void ValgrindRunControl::handleProgressFinished()
 {
     QApplication::alert(ICore::mainWindow(), 3000);
 }
 
-void ValgrindEngine::runnerFinished()
+void ValgrindRunControl::runnerFinished()
 {
-    emit outputReceived(tr("** Analyzing finished **\n"), NormalMessageFormat);
+    appendMessage(tr("** Analyzing finished **\n"), NormalMessageFormat);
     emit finished();
 
     m_progress->reportFinished();
@@ -159,7 +159,7 @@ void ValgrindEngine::runnerFinished()
                this, SLOT(runnerFinished()));
 }
 
-void ValgrindEngine::receiveProcessOutput(const QByteArray &output, OutputFormat format)
+void ValgrindRunControl::receiveProcessOutput(const QByteArray &output, OutputFormat format)
 {
     int progress = m_progress->progressValue();
     if (progress < 5 * progressMaximum / 10)
@@ -167,21 +167,21 @@ void ValgrindEngine::receiveProcessOutput(const QByteArray &output, OutputFormat
     else if (progress < 9 * progressMaximum / 10)
         progress += progress / 1000;
     m_progress->setProgressValue(progress);
-    emit outputReceived(QString::fromLocal8Bit(output), format);
+    appendMessage(QString::fromLocal8Bit(output), format);
 }
 
-void ValgrindEngine::receiveProcessError(const QString &message, QProcess::ProcessError error)
+void ValgrindRunControl::receiveProcessError(const QString &message, QProcess::ProcessError error)
 {
     if (error == QProcess::FailedToStart) {
         const QString &valgrind = m_settings->subConfig<ValgrindBaseSettings>()->valgrindExecutable();
         if (!valgrind.isEmpty())
-            emit outputReceived(tr("** Error: \"%1\" could not be started: %2 **\n").arg(valgrind).arg(message), ErrorMessageFormat);
+            appendMessage(tr("** Error: \"%1\" could not be started: %2 **\n").arg(valgrind).arg(message), ErrorMessageFormat);
         else
-            emit outputReceived(tr("** Error: no valgrind executable set **\n"), ErrorMessageFormat);
+            appendMessage(tr("** Error: no valgrind executable set **\n"), ErrorMessageFormat);
     } else if (m_isStopping && error == QProcess::Crashed) { // process gets killed on stop
-        emit outputReceived(tr("** Process Terminated **\n"), ErrorMessageFormat);
+        appendMessage(tr("** Process Terminated **\n"), ErrorMessageFormat);
     } else {
-        emit outputReceived(QString::fromLatin1("** %1 **\n").arg(message), ErrorMessageFormat);
+        appendMessage(QString::fromLatin1("** %1 **\n").arg(message), ErrorMessageFormat);
     }
 
     if (m_isStopping)

src/plugins/valgrind/valgrindengine.h

@@ -31,7 +31,7 @@
 #ifndef VALGRINDENGINE_H
 #define VALGRINDENGINE_H
 
-#include <analyzerbase/ianalyzerengine.h>
+#include <analyzerbase/analyzerruncontrol.h>
 #include <utils/environment.h>
 #include <valgrind/valgrindrunner.h>
 
@@ -43,17 +43,17 @@ namespace Analyzer { class AnalyzerSettings; }
 namespace Valgrind {
 namespace Internal {
 
-class ValgrindEngine : public Analyzer::IAnalyzerEngine
+class ValgrindRunControl : public Analyzer::AnalyzerRunControl
 {
     Q_OBJECT
 
 public:
-    ValgrindEngine(const Analyzer::AnalyzerStartParameters &sp,
+    ValgrindRunControl(const Analyzer::AnalyzerStartParameters &sp,
         ProjectExplorer::RunConfiguration *runConfiguration);
-    ~ValgrindEngine();
+    ~ValgrindRunControl();
 
-    bool start();
-    void stop();
+    bool startEngine();
+    void stopEngine();
 
     QString executable() const;
 

src/plugins/valgrind/valgrindplugin.cpp

@@ -75,7 +75,8 @@ static void startRemoteTool(IAnalyzerTool *tool)
     sp.displayName = dlg.executable();
     sp.workingDirectory = dlg.workingDirectory();
 
-    AnalyzerRunControl *rc = new AnalyzerRunControl(tool, sp, 0);
+    //AnalyzerRunControl *rc = new AnalyzerRunControl(tool, sp, 0);
+    AnalyzerRunControl *rc = tool->createRunControl(sp, 0);
     //m_currentRunControl = rc;
     QObject::connect(AnalyzerManager::stopAction(), SIGNAL(triggered()), rc, SLOT(stopIt()));
 

src/plugins/valgrind/valgrindruncontrolfactory.cpp

@@ -122,8 +122,7 @@ RunControl *ValgrindRunControlFactory::create(RunConfiguration *runConfiguration
     AnalyzerStartParameters sp = createValgrindStartParameters(runConfiguration);
     sp.toolId = tool->id();
 
-    AnalyzerRunControl *rc = new AnalyzerRunControl(tool, sp, runConfiguration);
-    return rc;
+    return tool->createRunControl(sp, runConfiguration);
 }
 
 IRunConfigurationAspect *ValgrindRunControlFactory::createRunConfigurationAspect(RunConfiguration *rc)