Replay and parse json in a thread.

[apitrace] / gui / retracer.cpp

diff --git a/gui/retracer.cpp b/gui/retracer.cpp
index b9d74b627ac429f7d5bfcfc6ba82fe0bbb9ae154..8f3508770457b6ac36fcaf6ff31de4d393904703 100644 (file)
--- a/gui/retracer.cpp
+++ b/gui/retracer.cpp
@@ -1,15 +1,31 @@
 #include "retracer.h"
 
+#include "apitracecall.h"
+
 #include <QDebug>
+#include <QVariant>
+
+#include <qjson/parser.h>
 
 Retracer::Retracer(QObject *parent)
-    : QObject(parent),
+    : QThread(parent),
       m_benchmarking(true),
       m_doubleBuffered(true),
       m_captureState(false),
-      m_captureCall(0),
-      m_process(0)
+      m_captureCall(0)
 {
+#ifdef Q_OS_WIN
+    QString format = QLatin1String("%1;");
+#else
+    QString format = QLatin1String("%1:");
+#endif
+    QString buildPath = format.arg(BUILD_DIR);
+    m_processEnvironment = QProcessEnvironment::systemEnvironment();
+    m_processEnvironment.insert("PATH", buildPath +
+                                m_processEnvironment.value("PATH"));
+
+    qputenv("PATH",
+            m_processEnvironment.value("PATH").toLatin1());
 }
 
 QString Retracer::fileName() const
@@ -42,31 +58,65 @@ void Retracer::setDoubleBuffered(bool db)
     m_doubleBuffered = db;
 }
 
-void Retracer::start()
+void Retracer::setCaptureAtCallNumber(qlonglong num)
 {
-    if (!m_process) {
-#ifdef Q_OS_WIN
-        QString format = QLatin1String("%1;");
-#else
-        QString format = QLatin1String("%1:");
-#endif
-        QString buildPath = format.arg(BUILD_DIR);
-        QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
-        env.insert("PATH", buildPath + env.value("PATH"));
+    m_captureCall = num;
+}
+
+qlonglong Retracer::captureAtCallNumber() const
+{
+    return m_captureCall;
+}
+
+bool Retracer::captureState() const
+{
+    return m_captureState;
+}
+
+void Retracer::setCaptureState(bool enable)
+{
+    m_captureState = enable;
+}
+
 
-        qputenv("PATH", env.value("PATH").toLatin1());
+void Retracer::run()
+{
+    RetraceProcess *retrace = new RetraceProcess();
+    retrace->process()->setProcessEnvironment(m_processEnvironment);
+
+    retrace->setFileName(m_fileName);
+    retrace->setBenchmarking(m_benchmarking);
+    retrace->setDoubleBuffered(m_doubleBuffered);
+    retrace->setCaptureState(m_captureState);
+    retrace->setCaptureAtCallNumber(m_captureCall);
+
+    connect(retrace, SIGNAL(finished(const QString&)),
+            this, SLOT(cleanup()));
+    connect(retrace, SIGNAL(error(const QString&)),
+            this, SLOT(cleanup()));
+    connect(retrace, SIGNAL(finished(const QString&)),
+            this, SIGNAL(finished(const QString&)));
+    connect(retrace, SIGNAL(error(const QString&)),
+            this, SIGNAL(error(const QString&)));
+    connect(retrace, SIGNAL(foundState(const ApiTraceState&)),
+            this, SIGNAL(foundState(const ApiTraceState&)));
+
+    retrace->start();
 
-        m_process = new QProcess(this);
-        m_process->setProcessEnvironment(env);
+    exec();
 
-        connect(m_process, SIGNAL(finished(int, QProcess::ExitStatus)),
-                this, SLOT(replayFinished()));
-        connect(m_process, SIGNAL(error(QProcess::ProcessError)),
-                this, SLOT(replayError(QProcess::ProcessError)));
+    /* means we need to kill the process */
+    if (retrace->process()->state() != QProcess::NotRunning) {
+        retrace->terminate();
     }
 
-    QStringList arguments;
+    delete retrace;
+}
+
 
+void RetraceProcess::start()
+{
+    QStringList arguments;
     if (m_captureState) {
         arguments << QLatin1String("-D");
         arguments << QString::number(m_captureCall);
@@ -84,53 +134,124 @@ void Retracer::start()
     m_process->start(QLatin1String("glretrace"), arguments);
 }
 
-void Retracer::terminate()
+
+void RetraceProcess::replayFinished()
 {
-    if (m_process) {
-        m_process->terminate();
+    QByteArray output = m_process->readAllStandardOutput();
+    QString msg;
+
+#if 0
+    qDebug()<<"Process finished = ";
+    qDebug()<<"\terr = "<<m_process->readAllStandardError();
+    qDebug()<<"\tout = "<<output;
+#endif
+    if (m_captureState) {
+        bool ok = false;
+        QVariantMap parsedJson = m_jsonParser->parse(output, &ok).toMap();
+        ApiTraceState state(parsedJson);
+        emit foundState(state);
+        msg = tr("State fetched.");
+    } else {
+        msg = QString::fromUtf8(output);
     }
+
+    emit finished(msg);
 }
 
-void Retracer::setCaptureAtCallNumber(qlonglong num)
+void RetraceProcess::replayError(QProcess::ProcessError err)
+{
+    qDebug()<<"Process error = "<<err;
+    qDebug()<<"\terr = "<<m_process->readAllStandardError();
+    qDebug()<<"\tout = "<<m_process->readAllStandardOutput();
+
+    emit error(
+        tr("Couldn't execute the replay file '%1'").arg(m_fileName));
+}
+
+
+RetraceProcess::RetraceProcess(QObject *parent)
+    : QObject(parent)
+{
+    m_process = new QProcess(this);
+    m_jsonParser = new QJson::Parser();
+
+    connect(m_process, SIGNAL(finished(int, QProcess::ExitStatus)),
+            this, SLOT(replayFinished()));
+    connect(m_process, SIGNAL(error(QProcess::ProcessError)),
+            this, SLOT(replayError(QProcess::ProcessError)));
+}
+
+QProcess * RetraceProcess::process() const
+{
+    return m_process;
+}
+
+QString RetraceProcess::fileName() const
+{
+    return m_fileName;
+}
+
+void RetraceProcess::setFileName(const QString &name)
+{
+    m_fileName = name;
+}
+
+bool RetraceProcess::isBenchmarking() const
+{
+    return m_benchmarking;
+}
+
+void RetraceProcess::setBenchmarking(bool bench)
+{
+    m_benchmarking = bench;
+}
+
+bool RetraceProcess::isDoubleBuffered() const
+{
+    return m_doubleBuffered;
+}
+
+void RetraceProcess::setDoubleBuffered(bool db)
+{
+    m_doubleBuffered = db;
+}
+
+void RetraceProcess::setCaptureAtCallNumber(qlonglong num)
 {
     m_captureCall = num;
 }
 
-qlonglong Retracer::captureAtCallNumber() const
+qlonglong RetraceProcess::captureAtCallNumber() const
 {
     return m_captureCall;
 }
 
-bool Retracer::captureState() const
+bool RetraceProcess::captureState() const
 {
     return m_captureState;
 }
 
-void Retracer::setCaptureState(bool enable)
+void RetraceProcess::setCaptureState(bool enable)
 {
     m_captureState = enable;
 }
 
-void Retracer::replayFinished()
+void RetraceProcess::terminate()
 {
-    QByteArray output = m_process->readAllStandardOutput();
-
-#if 0
-    qDebug()<<"Process finished = ";
-    qDebug()<<"\terr = "<<m_process->readAllStandardError();
-    qDebug()<<"\tout = "<<output;
-#endif
-    emit finished(output);
+    if (m_process) {
+        m_process->terminate();
+        emit finished(tr("Process terminated."));
+    }
 }
 
-void Retracer::replayError(QProcess::ProcessError err)
+void Retracer::cleanup()
 {
-    qDebug()<<"Process error = "<<err;
-    qDebug()<<"\terr = "<<m_process->readAllStandardError();
-    qDebug()<<"\tout = "<<m_process->readAllStandardOutput();
+    quit();
+}
 
-    emit error(
-        tr("Couldn't execute the replay file '%1'").arg(m_fileName));
+RetraceProcess::~RetraceProcess()
+{
+    delete m_jsonParser;
 }
 
 #include "retracer.moc"