Valgrind: Dissolve CallGrindRunner

Basically merge with CallGrindToolRunner, to which there was
a 1:1 relationship.

Change-Id: Iebd9325c36e82b966f873d380395065e087958e4
Reviewed-by: Christian Stenger <christian.stenger@qt.io>

src/plugins/valgrind/callgrind/callgrind.pri

@@ -14,8 +14,7 @@ HEADERS += \
     $$PWD/callgrindcontroller.h \
     $$PWD/callgrindcycledetection.h \
     $$PWD/callgrindproxymodel.h \
-    $$PWD/callgrindstackbrowser.h \
+    $$PWD/callgrindstackbrowser.h
-    $$PWD/callgrindrunner.h
 
 SOURCES += \
     $$PWD/callgrindparser.cpp \
@@ -29,5 +28,4 @@ SOURCES += \
     $$PWD/callgrindcontroller.cpp \
     $$PWD/callgrindcycledetection.cpp \
     $$PWD/callgrindproxymodel.cpp \
-    $$PWD/callgrindrunner.cpp \
     $$PWD/callgrindstackbrowser.cpp

src/plugins/valgrind/callgrind/callgrindrunner.cpp

@@ -1,123 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of Qt Creator.
-**
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3 as published by the Free Software
-** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-3.0.html.
-**
-****************************************************************************/
-
-#include "callgrindrunner.h"
-#include "callgrindparser.h"
-
-#include <utils/qtcassert.h>
-
-#include <QFile>
-
-namespace Valgrind {
-namespace Callgrind {
-
-CallgrindRunner::CallgrindRunner(QObject *parent)
-    : ValgrindRunner(parent)
-    , m_controller(new CallgrindController(this))
-    , m_parser(new Parser(this))
-    , m_paused(false)
-{
-    connect(m_controller, &CallgrindController::finished,
-            this, &CallgrindRunner::controllerFinished);
-    connect(m_controller, &CallgrindController::localParseDataAvailable,
-            this, &CallgrindRunner::localParseDataAvailable);
-    connect(m_controller, &CallgrindController::statusMessage,
-            this, &CallgrindRunner::statusMessage);
-}
-
-QString CallgrindRunner::tool() const
-{
-    return QLatin1String("callgrind");
-}
-
-Parser *CallgrindRunner::parser() const
-{
-    return m_parser;
-}
-
-CallgrindController *CallgrindRunner::controller() const
-{
-    return m_controller;
-}
-
-bool CallgrindRunner::start()
-{
-    ValgrindRunner::start();
-    m_controller->setValgrindProcess(valgrindProcess());
-    return true;
-}
-
-void CallgrindRunner::processFinished(int ret, QProcess::ExitStatus status)
-{
-    triggerParse();
-    m_controller->setValgrindProcess(0);
-
-    ValgrindRunner::processFinished(ret, status); // call base class function
-}
-
-bool CallgrindRunner::isPaused() const
-{
-    return m_paused;
-}
-
-void CallgrindRunner::triggerParse()
-{
-    m_controller->getLocalDataFile();
-}
-
-void CallgrindRunner::localParseDataAvailable(const QString &file)
-{
-    // parse the callgrind file
-    QTC_ASSERT(!file.isEmpty(), return);
-    QFile outputFile(file);
-    QTC_ASSERT(outputFile.exists(), return);
-    if (outputFile.open(QIODevice::ReadOnly)) {
-        emit statusMessage(tr("Parsing Profile Data..."));
-        m_parser->parse(&outputFile);
-    } else {
-        qWarning() << "Could not open file for parsing:" << outputFile.fileName();
-    }
-}
-
-void CallgrindRunner::controllerFinished(CallgrindController::Option option)
-{
-    switch (option)
-    {
-    case CallgrindController::Pause:
-        m_paused = true;
-        break;
-    case CallgrindController::UnPause:
-        m_paused = false;
-        break;
-    case CallgrindController::Dump:
-        triggerParse();
-        break;
-    default:
-        break; // do nothing
-    }
-}
-
-} // namespace Callgrind
-} // namespace Valgrind

src/plugins/valgrind/callgrind/callgrindrunner.h

@@ -1,69 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of Qt Creator.
-**
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3 as published by the Free Software
-** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-3.0.html.
-**
-****************************************************************************/
-
-#pragma once
-
-#include "../valgrindrunner.h"
-
-#include "callgrindcontroller.h"
-
-namespace Valgrind {
-namespace Callgrind {
-
-class Parser;
-class CallgrindController;
-
-class CallgrindRunner : public ValgrindRunner
-{
-    Q_OBJECT
-
-public:
-    explicit CallgrindRunner(QObject *parent = 0);
-
-    Parser *parser() const;
-
-    CallgrindController *controller() const;
-
-    bool isPaused() const;
-    bool start();
-
-signals:
-    void statusMessage(const QString &message);
-
-private:
-    void processFinished(int, QProcess::ExitStatus);
-    QString tool() const;
-
-    void localParseDataAvailable(const QString &file);
-    void controllerFinished(Valgrind::Callgrind::CallgrindController::Option);
-    void triggerParse();
-
-    CallgrindController *m_controller;
-    Parser *m_parser;
-    bool m_paused;
-};
-
-} // namespace Callgrind
-} // namespace Valgrind

src/plugins/valgrind/callgrindengine.cpp

@@ -38,17 +38,34 @@
 using namespace Debugger;
 using namespace Valgrind;
 using namespace Valgrind::Internal;
+using namespace Valgrind::Callgrind;
 
 CallgrindToolRunner::CallgrindToolRunner(ProjectExplorer::RunControl *runControl)
     : ValgrindToolRunner(runControl)
 {
     setDisplayName("CallgrindToolRunner");
-    connect(&m_runner, &Callgrind::CallgrindRunner::finished,
+    m_runner.setToolName("callgrind");
+
+    connect(&m_runner, &ValgrindRunner::finished,
             this, &CallgrindToolRunner::slotFinished);
-    connect(m_runner.parser(), &Callgrind::Parser::parserDataReady,
+    connect(&m_parser, &Callgrind::Parser::parserDataReady,
             this, &CallgrindToolRunner::slotFinished);
-    connect(&m_runner, &Callgrind::CallgrindRunner::statusMessage,
+
-            this, &Debugger::showPermanentStatusMessage);
+    connect(&m_controller, &CallgrindController::finished,
+            this, &CallgrindToolRunner::controllerFinished);
+    connect(&m_controller, &CallgrindController::localParseDataAvailable,
+            this, &CallgrindToolRunner::localParseDataAvailable);
+    connect(&m_controller, &CallgrindController::statusMessage,
+            this, &CallgrindToolRunner::showStatusMessage);
+
+    connect(&m_runner, &ValgrindRunner::extraStart, this, [this] {
+        m_controller.setValgrindProcess(m_runner.valgrindProcess());
+    });
+
+    connect(&m_runner, &ValgrindRunner::extraProcessFinished, this, [this] {
+        triggerParse();
+        m_controller.setValgrindProcess(nullptr);
+    });
 }
 
 QStringList CallgrindToolRunner::toolArguments() const
@@ -97,7 +114,7 @@ void CallgrindToolRunner::start()
 
 void CallgrindToolRunner::dump()
 {
-    m_runner.controller()->run(Callgrind::CallgrindController::Dump);
+    m_controller.run(CallgrindController::Dump);
 }
 
 void CallgrindToolRunner::setPaused(bool paused)
@@ -108,7 +125,7 @@ void CallgrindToolRunner::setPaused(bool paused)
     m_markAsPaused = paused;
 
     // call controller only if it is attached to a valgrind process
-    if (m_runner.controller()->valgrindProcess()) {
+    if (m_controller.valgrindProcess()) {
         if (paused)
             pause();
         else
@@ -126,25 +143,67 @@ void CallgrindToolRunner::setToggleCollectFunction(const QString &toggleCollectF
 
 void CallgrindToolRunner::reset()
 {
-    m_runner.controller()->run(Callgrind::CallgrindController::ResetEventCounters);
+    m_controller.run(Callgrind::CallgrindController::ResetEventCounters);
 }
 
 void CallgrindToolRunner::pause()
 {
-    m_runner.controller()->run(Callgrind::CallgrindController::Pause);
+    m_controller.run(Callgrind::CallgrindController::Pause);
 }
 
 void CallgrindToolRunner::unpause()
 {
-    m_runner.controller()->run(Callgrind::CallgrindController::UnPause);
+    m_controller.run(Callgrind::CallgrindController::UnPause);
 }
 
 Callgrind::ParseData *CallgrindToolRunner::takeParserData()
 {
-    return m_runner.parser()->takeData();
+    return m_parser.takeData();
 }
 
 void CallgrindToolRunner::slotFinished()
 {
     emit parserDataReady(this);
 }
+
+void CallgrindToolRunner::showStatusMessage(const QString &message)
+{
+    Debugger::showPermanentStatusMessage(message);
+}
+
+void CallgrindToolRunner::triggerParse()
+{
+    m_controller.getLocalDataFile();
+}
+
+void CallgrindToolRunner::localParseDataAvailable(const QString &file)
+{
+    // parse the callgrind file
+    QTC_ASSERT(!file.isEmpty(), return);
+    QFile outputFile(file);
+    QTC_ASSERT(outputFile.exists(), return);
+    if (outputFile.open(QIODevice::ReadOnly)) {
+        showStatusMessage(tr("Parsing Profile Data..."));
+        m_parser.parse(&outputFile);
+    } else {
+        qWarning() << "Could not open file for parsing:" << outputFile.fileName();
+    }
+}
+
+void CallgrindToolRunner::controllerFinished(CallgrindController::Option option)
+{
+    switch (option)
+    {
+    case CallgrindController::Pause:
+        m_paused = true;
+        break;
+    case CallgrindController::UnPause:
+        m_paused = false;
+        break;
+    case CallgrindController::Dump:
+        triggerParse();
+        break;
+    default:
+        break; // do nothing
+    }
+}

src/plugins/valgrind/callgrindengine.h

@@ -25,10 +25,12 @@
 
 #pragma once
 
-#include <valgrind/valgrindengine.h>
+#include "valgrindengine.h"
+#include "valgrindrunner.h"
 
-#include <valgrind/callgrind/callgrindrunner.h>
+#include "callgrind/callgrindparsedata.h"
-#include <valgrind/callgrind/callgrindparsedata.h>
+#include "callgrind/callgrindparser.h"
+#include "callgrind/callgrindcontroller.h"
 
 namespace Valgrind {
 namespace Internal {
@@ -66,9 +68,17 @@ signals:
 
 private:
     void slotFinished();
+    void showStatusMessage(const QString &message);
 
-    Valgrind::Callgrind::CallgrindRunner m_runner;
+    void triggerParse();
+    void localParseDataAvailable(const QString &file);
+    void controllerFinished(Callgrind::CallgrindController::Option option);
+
+    ValgrindRunner m_runner;
     bool m_markAsPaused = false;
+    Callgrind::CallgrindController m_controller;
+    Callgrind::Parser m_parser;
+    bool m_paused = false;
 
     QString m_argumentForToggleCollect;
 };

src/plugins/valgrind/memcheck/memcheckrunner.cpp

@@ -68,6 +68,7 @@ MemcheckRunner::MemcheckRunner(QObject *parent)
     : ValgrindRunner(parent),
       d(new Private)
 {
+    setToolName("memcheck");
 }
 
 MemcheckRunner::~MemcheckRunner()
@@ -80,11 +81,6 @@ MemcheckRunner::~MemcheckRunner()
     d = 0;
 }
 
-QString MemcheckRunner::tool() const
-{
-    return QLatin1String("memcheck");
-}
-
 void MemcheckRunner::setParser(XmlProtocol::ThreadedParser *parser)
 {
     QTC_ASSERT(!d->parser, qt_noop());

src/plugins/valgrind/memcheck/memcheckrunner.h

@@ -45,21 +45,19 @@ public:
     ~MemcheckRunner();
 
     void setParser(XmlProtocol::ThreadedParser *parser);
-    bool start();
+    bool start() override;
     void disableXml();
 
 signals:
     void logMessageReceived(const QByteArray &);
 
 private:
-    void localHostAddressRetrieved(const QHostAddress &localHostAddress);
+    void localHostAddressRetrieved(const QHostAddress &localHostAddress) override;
 
     void xmlSocketConnected();
     void logSocketConnected();
     void readLogSocket();
 
-    QString tool() const;
-
     bool startServers(const QHostAddress &localHostAddress);
     QStringList memcheckLogArguments() const;
 

src/plugins/valgrind/valgrind.qbs

@@ -58,7 +58,6 @@ QtcPlugin {
             "callgrindparsedata.cpp", "callgrindparsedata.h",
             "callgrindparser.cpp", "callgrindparser.h",
             "callgrindproxymodel.cpp", "callgrindproxymodel.h",
-            "callgrindrunner.cpp", "callgrindrunner.h",
             "callgrindstackbrowser.cpp", "callgrindstackbrowser.h"
         ]
     }

src/plugins/valgrind/valgrind_test.pri

@@ -27,7 +27,6 @@ HEADERS += \
     $$PWD/callgrind/callgrindcycledetection.h \
     $$PWD/callgrind/callgrindproxymodel.h \
     $$PWD/callgrind/callgrindstackbrowser.h \
-    $$PWD/callgrind/callgrindrunner.h \
     $$PWD/memcheck/memcheckrunner.h \
     $$PWD/valgrindrunner.h \
     $$PWD/valgrindprocess.h
@@ -54,7 +53,6 @@ SOURCES += $$PWD/xmlprotocol/error.cpp \
     $$PWD/callgrind/callgrindcontroller.cpp \
     $$PWD/callgrind/callgrindcycledetection.cpp \
     $$PWD/callgrind/callgrindproxymodel.cpp \
-    $$PWD/callgrind/callgrindrunner.cpp \
     $$PWD/callgrind/callgrindstackbrowser.cpp \
     $$PWD/memcheck/memcheckrunner.cpp \
     $$PWD/valgrindrunner.cpp \

src/plugins/valgrind/valgrindrunner.cpp

@@ -52,6 +52,7 @@ public:
     QStringList valgrindArguments;
     StandardRunnable debuggee;
     IDevice::ConstPtr device;
+    QString tool;
 };
 
 ValgrindRunner::ValgrindRunner(QObject *parent)
@@ -92,7 +93,7 @@ QStringList ValgrindRunner::valgrindArguments() const
 QStringList ValgrindRunner::fullValgrindArguments() const
 {
     QStringList fullArgs = valgrindArguments();
-    fullArgs << QString::fromLatin1("--tool=%1").arg(tool());
+    fullArgs << QString("--tool=%1").arg(d->tool);
     if (Utils::HostOsInfo::isMacHost())
         // May be slower to start but without it we get no filenames for symbols.
         fullArgs << QLatin1String("--dsymutil=yes");
@@ -129,6 +130,11 @@ void ValgrindRunner::waitForFinished() const
     loop.exec();
 }
 
+void ValgrindRunner::setToolName(const QString &toolName)
+{
+    d->tool = toolName;
+}
+
 bool ValgrindRunner::start()
 {
     d->process = new ValgrindProcess(d->device, this);
@@ -151,6 +157,9 @@ bool ValgrindRunner::start()
                      this, &ValgrindRunner::localHostAddressRetrieved);
 
     d->process->run(d->debuggee.runMode);
+
+    emit extraStart();
+
     return true;
 }
 
@@ -168,6 +177,8 @@ void ValgrindRunner::processError(QProcess::ProcessError e)
 
 void ValgrindRunner::processFinished(int ret, QProcess::ExitStatus status)
 {
+    emit extraProcessFinished();
+
     if (d->finished)
         return;
 

src/plugins/valgrind/valgrindrunner.h

@@ -59,22 +59,25 @@ public:
     ProjectExplorer::IDevice::ConstPtr device() const;
 
     void waitForFinished() const;
+    void setToolName(const QString &toolName);
 
     QString errorString() const;
 
     virtual bool start();
-    virtual void stop();
+    void stop();
 
     ValgrindProcess *valgrindProcess() const;
 
 signals:
+    void extraStart();
+
     void processOutputReceived(const QString &, Utils::OutputFormat);
     void processErrorReceived(const QString &, QProcess::ProcessError);
     void started();
     void finished();
+    void extraProcessFinished();
 
 protected:
-    virtual QString tool() const = 0;
     virtual void processError(QProcess::ProcessError);
     virtual void processFinished(int, QProcess::ExitStatus);
     virtual void localHostAddressRetrieved(const QHostAddress &localHostAddress);