QmlProfiler: Integrate TraceTime into ModelManager

We never use it independently and only a subset of its interface needs
to be public.

Change-Id: I97bbc638270bcbb8fb1a4097fcfeacf37e96c048
Reviewed-by: Tobias Hunger <tobias.hunger@qt.io>

src/plugins/qmlprofiler/debugmessagesmodel.cpp

@@ -81,7 +81,7 @@ QVariantMap DebugMessagesModel::details(int index) const
     QVariantMap result;
     result.insert(QLatin1String("displayName"), messageType(type.detailType()));
     result.insert(tr("Timestamp"), Timeline::formatTime(startTime(index),
-                                                        manager->traceTime()->duration()));
+                                                        manager->traceDuration()));
     result.insert(tr("Message"), m_data[index].text);
     result.insert(tr("Location"), type.displayName());
     return result;

src/plugins/qmlprofiler/flamegraphmodel.cpp

@@ -176,8 +176,7 @@ void FlameGraphModel::restrictToFeatures(quint64 visibleFeatures)
 
     clear();
     beginResetModel();
-    if (!m_modelManager->replayEvents(m_modelManager->traceTime()->startTime(),
+    if (!m_modelManager->replayEvents(m_modelManager->traceStart(), m_modelManager->traceEnd(),
-                                      m_modelManager->traceTime()->endTime(),
                                       std::bind(&FlameGraphModel::loadEvent,
                                                 this, std::placeholders::_1,
                                                 std::placeholders::_2))) {

src/plugins/qmlprofiler/inputeventsmodel.cpp

@@ -78,7 +78,7 @@ QVariantMap InputEventsModel::details(int index) const
 {
     QVariantMap result;
     result.insert(tr("Timestamp"), Timeline::formatTime(startTime(index),
-                                                        modelManager()->traceTime()->duration()));
+                                                        modelManager()->traceDuration()));
     QString type;
     const InputEvent &event = m_data[index];
     switch (event.type) {

src/plugins/qmlprofiler/memoryusagemodel.cpp

@@ -234,12 +234,12 @@ void MemoryUsageModel::loadEvent(const QmlEvent &event, const QmlEventType &type
 
 void MemoryUsageModel::finalize()
 {
-    if (m_currentJSHeapIndex != -1)
+    if (m_currentJSHeapIndex != -1) {
-        insertEnd(m_currentJSHeapIndex, modelManager()->traceTime()->endTime() -
+        insertEnd(m_currentJSHeapIndex,
-                  startTime(m_currentJSHeapIndex));
+                  modelManager()->traceEnd() - startTime(m_currentJSHeapIndex));
+    }
     if (m_currentUsageIndex != -1)
-        insertEnd(m_currentUsageIndex, modelManager()->traceTime()->endTime() -
+        insertEnd(m_currentUsageIndex, modelManager()->traceEnd() - startTime(m_currentUsageIndex));
-                  startTime(m_currentUsageIndex));
 
 
     computeNesting();

src/plugins/qmlprofiler/pixmapcachemodel.cpp

@@ -331,7 +331,7 @@ void PixmapCacheModel::loadEvent(const QmlEvent &event, const QmlEventType &type
         if (state.loadState == Initial) {
             newEvent.pixmapEventType = PixmapLoadingStarted;
             newEvent.typeId = event.typeIndex();
-            qint64 traceStart = modelManager()->traceTime()->startTime();
+            const qint64 traceStart = modelManager()->traceStart();
             state.started = insert(traceStart, pixmapStartTime - traceStart,
                                    newEvent.urlIndex + 1);
             m_data.insert(state.started, newEvent);
@@ -382,8 +382,8 @@ void PixmapCacheModel::loadEvent(const QmlEvent &event, const QmlEventType &type
 void PixmapCacheModel::finalize()
 {
     if (m_lastCacheSizeEvent != -1) {
-        insertEnd(m_lastCacheSizeEvent, modelManager()->traceTime()->endTime() -
+        insertEnd(m_lastCacheSizeEvent,
-                  startTime(m_lastCacheSizeEvent));
+                  modelManager()->traceEnd() - startTime(m_lastCacheSizeEvent));
     }
 
     resizeUnfinishedLoads();
@@ -446,8 +446,7 @@ void PixmapCacheModel::resizeUnfinishedLoads()
         for (auto size = pixmap->sizes.begin(), sizesEnd = pixmap->sizes.end(); size != sizesEnd;
              ++size) {
             if (size->loadState == Loading) {
-                insertEnd(size->started,
+                insertEnd(size->started, modelManager()->traceEnd() - startTime(size->started));
-                          modelManager()->traceTime()->endTime() - startTime(size->started));
                 size->loadState = Error;
             }
         }

src/plugins/qmlprofiler/qmlprofilerclientmanager.cpp

@@ -91,7 +91,7 @@ void QmlProfilerClientManager::createClients()
     m_clientPlugin->setFlushInterval(m_flushInterval);
 
     QObject::connect(m_clientPlugin.data(), &QmlProfilerTraceClient::traceFinished,
-                     m_modelManager->traceTime(), &QmlProfilerTraceTime::increaseEndTime);
+                     m_modelManager, &QmlProfilerModelManager::increaseTraceEnd);
 
     QObject::connect(m_profilerState.data(), &QmlProfilerStateManager::requestedFeaturesChanged,
                      m_clientPlugin.data(), &QmlProfilerTraceClient::setRequestedFeatures);
@@ -101,11 +101,11 @@ void QmlProfilerClientManager::createClients()
     QObject::connect(m_clientPlugin.data(), &QmlProfilerTraceClient::traceStarted,
                      this, [this](qint64 time) {
         m_profilerState->setServerRecording(true);
-        m_modelManager->traceTime()->decreaseStartTime(time);
+        m_modelManager->decreaseTraceStart(time);
     });
 
     QObject::connect(m_clientPlugin, &QmlProfilerTraceClient::complete, this, [this](qint64 time) {
-        m_modelManager->traceTime()->increaseEndTime(time);
+        m_modelManager->increaseTraceEnd(time);
         m_profilerState->setServerRecording(false);
     });
 

src/plugins/qmlprofiler/qmlprofilermodelmanager.cpp

@@ -62,85 +62,9 @@ static const char *ProfileFeatureNames[] = {
 
 Q_STATIC_ASSERT(sizeof(ProfileFeatureNames) == sizeof(char *) * MaximumProfileFeature);
 
-/////////////////////////////////////////////////////////////////////
-QmlProfilerTraceTime::QmlProfilerTraceTime(QObject *parent) :
-    QObject(parent), m_startTime(-1), m_endTime(-1),
-    m_restrictedStartTime(-1), m_restrictedEndTime(-1)
-{
-}
-
-qint64 QmlProfilerTraceTime::startTime() const
-{
-    return m_restrictedStartTime != -1 ? m_restrictedStartTime : m_startTime;
-}
-
-qint64 QmlProfilerTraceTime::endTime() const
-{
-    return m_restrictedEndTime != -1 ? m_restrictedEndTime : m_endTime;
-}
-
-qint64 QmlProfilerTraceTime::duration() const
-{
-    return endTime() - startTime();
-}
-
-bool QmlProfilerTraceTime::isRestrictedToRange() const
-{
-    return m_restrictedStartTime != -1 || m_restrictedEndTime != -1;
-}
-
-void QmlProfilerTraceTime::clear()
-{
-    restrictToRange(-1, -1);
-    m_startTime = -1;
-    m_endTime = -1;
-}
-
-void QmlProfilerTraceTime::update(qint64 time)
-{
-    QTC_ASSERT(time >= 0, return);
-    if (m_startTime > time || m_startTime == -1)
-        m_startTime = time;
-    if (m_endTime < time || m_endTime == -1)
-        m_endTime = time;
-    QTC_ASSERT(m_endTime >= m_startTime, m_startTime = m_endTime);
-}
-
-void QmlProfilerTraceTime::decreaseStartTime(qint64 time)
-{
-    QTC_ASSERT(time >= 0, return);
-    if (m_startTime > time || m_startTime == -1) {
-        m_startTime = time;
-        if (m_endTime == -1)
-            m_endTime = m_startTime;
-        else
-            QTC_ASSERT(m_endTime >= m_startTime, m_endTime = m_startTime);
-    }
-}
-
-void QmlProfilerTraceTime::increaseEndTime(qint64 time)
-{
-    QTC_ASSERT(time >= 0, return);
-    if (m_endTime < time || m_endTime == -1) {
-        m_endTime = time;
-        if (m_startTime == -1)
-            m_startTime = m_endTime;
-        else
-            QTC_ASSERT(m_endTime >= m_startTime, m_startTime = m_endTime);
-    }
-}
-
-void QmlProfilerTraceTime::restrictToRange(qint64 startTime, qint64 endTime)
-{
-    QTC_ASSERT(endTime == -1 || startTime <= endTime, endTime = startTime);
-    m_restrictedStartTime = startTime;
-    m_restrictedEndTime = endTime;
-}
-
-
 } // namespace Internal
 
-/////////////////////////////////////////////////////////////////////
+using namespace Internal;
 
 class QmlProfilerModelManager::QmlProfilerModelManagerPrivate
 {
@@ -151,7 +75,6 @@ public:
     QmlProfilerTextMarkModel *textMarkModel = nullptr;
 
     QmlProfilerModelManager::State state = Empty;
-    QmlProfilerTraceTime *traceTime = nullptr;
 
     int numRegisteredModels = 0;
     int numFinishedFinalizers = 0;
@@ -171,16 +94,21 @@ public:
     Utils::TemporaryFile file;
     QDataStream eventStream;
 
+    qint64 traceStart = -1;
+    qint64 traceEnd = -1;
+    qint64 restrictedTraceStart = -1;
+    qint64 restrictedTraceEnd = -1;
+
     void dispatch(const QmlEvent &event, const QmlEventType &type);
     void rewriteType(int typeIndex);
     int resolveStackTop();
+    void updateTraceTime(qint64 time);
+    void restrictTraceTimeToRange(qint64 start, qint64 end);
 };
 
-
 QmlProfilerModelManager::QmlProfilerModelManager(QObject *parent) :
     QObject(parent), d(new QmlProfilerModelManagerPrivate)
 {
-    d->traceTime = new QmlProfilerTraceTime(this);
     d->notesModel = new QmlProfilerNotesModel(this);
     d->textMarkModel = new QmlProfilerTextMarkModel(this);
 
@@ -201,9 +129,43 @@ QmlProfilerModelManager::~QmlProfilerModelManager()
     delete d;
 }
 
-QmlProfilerTraceTime *QmlProfilerModelManager::traceTime() const
+qint64 QmlProfilerModelManager::traceStart() const
 {
-    return d->traceTime;
+    return d->restrictedTraceStart != -1 ? d->restrictedTraceStart : d->traceStart;
+}
+
+qint64 QmlProfilerModelManager::traceEnd() const
+{
+    return d->restrictedTraceEnd != -1 ? d->restrictedTraceEnd : d->traceEnd;
+}
+
+qint64 QmlProfilerModelManager::traceDuration() const
+{
+    return traceEnd() - traceStart();
+}
+
+void QmlProfilerModelManager::decreaseTraceStart(qint64 start)
+{
+    QTC_ASSERT(start >= 0, return);
+    if (d->traceStart > start || d->traceStart == -1) {
+        d->traceStart = start;
+        if (d->traceEnd == -1)
+            d->traceEnd = d->traceStart;
+        else
+            QTC_ASSERT(d->traceEnd >= d->traceStart, d->traceEnd = d->traceStart);
+    }
+}
+
+void QmlProfilerModelManager::increaseTraceEnd(qint64 end)
+{
+    QTC_ASSERT(end >= 0, return);
+    if (d->traceEnd < end || d->traceEnd == -1) {
+        d->traceEnd = end;
+        if (d->traceStart == -1)
+            d->traceStart = d->traceEnd;
+        else
+            QTC_ASSERT(d->traceEnd >= d->traceStart, d->traceStart = d->traceEnd);
+    }
 }
 
 QmlProfilerNotesModel *QmlProfilerModelManager::notesModel() const
@@ -250,7 +212,7 @@ void QmlProfilerModelManager::addEvents(const QVector<QmlEvent> &events)
 {
     for (const QmlEvent &event : events) {
         d->eventStream << event;
-        d->traceTime->update(event.timestamp());
+        d->updateTraceTime(event.timestamp());
         d->dispatch(event, d->eventTypes[event.typeIndex()]);
     }
 }
@@ -258,7 +220,7 @@ void QmlProfilerModelManager::addEvents(const QVector<QmlEvent> &events)
 void QmlProfilerModelManager::addEvent(const QmlEvent &event)
 {
     d->eventStream << event;
-    d->traceTime->update(event.timestamp());
+    d->updateTraceTime(event.timestamp());
     QTC_ASSERT(event.typeIndex() < d->eventTypes.size(),
                d->eventTypes.resize(event.typeIndex() + 1));
     d->dispatch(event, d->eventTypes.at(event.typeIndex()));
@@ -434,6 +396,23 @@ void QmlProfilerModelManager::QmlProfilerModelManagerPrivate::rewriteType(int ty
         detailsRewriter->requestDetailsForLocation(typeIndex, location);
 }
 
+void QmlProfilerModelManager::QmlProfilerModelManagerPrivate::updateTraceTime(qint64 time)
+{
+    QTC_ASSERT(time >= 0, return);
+    if (traceStart > time || traceStart == -1)
+        traceStart = time;
+    if (traceEnd < time || traceEnd == -1)
+        traceEnd = time;
+    QTC_ASSERT(traceEnd >= traceStart, traceStart = traceEnd);
+}
+
+void QmlProfilerModelManager::QmlProfilerModelManagerPrivate::restrictTraceTimeToRange(qint64 start, qint64 end)
+{
+    QTC_ASSERT(end == -1 || start <= end, end = start);
+    restrictedTraceStart = start;
+    restrictedTraceEnd = end;
+}
+
 void QmlProfilerModelManager::announceFeatures(quint64 features, EventLoader eventLoader,
                                                Finalizer finalizer)
 {
@@ -541,8 +520,7 @@ void QmlProfilerModelManager::save(const QString &filename)
     d->notesModel->stash();
 
     QmlProfilerFileWriter *writer = new QmlProfilerFileWriter(this);
-    writer->setTraceTime(traceTime()->startTime(), traceTime()->endTime(),
+    writer->setTraceTime(traceStart(), traceEnd(), traceDuration());
-                        traceTime()->duration());
     writer->setData(this);
     writer->setNotes(d->notesModel->notes());
 
@@ -609,9 +587,9 @@ void QmlProfilerModelManager::load(const QString &filename)
 
     connect(reader, &QmlProfilerFileReader::success, this, [this, reader]() {
         if (reader->traceStart() >= 0)
-            d->traceTime->decreaseStartTime(reader->traceStart());
+            decreaseTraceStart(reader->traceStart());
         if (reader->traceEnd() >= 0)
-            d->traceTime->increaseEndTime(reader->traceEnd());
+            increaseTraceEnd(reader->traceEnd());
         setRecordedFeatures(reader->loadedFeatures());
         delete reader;
         finalize();
@@ -691,7 +669,9 @@ void QmlProfilerModelManager::doClearEvents()
         d->eventStream.setDevice(&d->file);
     else
         emit error(tr("Cannot open temporary trace file to store events."));
-    d->traceTime->clear();
+    d->restrictTraceTimeToRange(-1, -1);
+    d->traceStart = -1;
+    d->traceEnd = -1;
     d->notesModel->clear();
     setVisibleFeatures(0);
     setRecordedFeatures(0);
@@ -731,14 +711,14 @@ void QmlProfilerModelManager::restrictToRange(qint64 startTime, qint64 endTime)
         clear();
     } else {
         d->notesModel->setNotes(notes);
-        d->traceTime->restrictToRange(startTime, endTime);
+        d->restrictTraceTimeToRange(startTime, endTime);
         finalize();
     }
 }
 
 bool QmlProfilerModelManager::isRestrictedToRange() const
 {
-    return d->traceTime->isRestrictedToRange();
+    return d->restrictedTraceStart != -1 || d->restrictedTraceEnd != -1;
 }
 
 void QmlProfilerModelManager::startAcquiring()

src/plugins/qmlprofiler/qmlprofilermodelmanager.h

@@ -43,38 +43,6 @@ namespace QmlProfiler {
 class QmlProfilerModelManager;
 class QmlProfilerNotesModel;
 
-namespace Internal {
-
-class QMLPROFILER_EXPORT QmlProfilerTraceTime : public QObject
-{
-    Q_OBJECT
-public:
-    explicit QmlProfilerTraceTime(QObject *parent);
-
-    qint64 startTime() const;
-    qint64 endTime() const;
-    qint64 duration() const;
-    bool isRestrictedToRange() const;
-
-    void clear();
-
-    void update(qint64 time);
-    void decreaseStartTime(qint64 time);
-    void increaseEndTime(qint64 time);
-    void restrictToRange(qint64 startTime, qint64 endTime);
-
-private:
-    qint64 m_startTime;
-    qint64 m_endTime;
-
-    qint64 m_restrictedStartTime;
-    qint64 m_restrictedEndTime;
-};
-
-} // End internal namespace
-
-using namespace Internal;
-
 // Interface between the Data Model and the Engine/Tool
 class QMLPROFILER_EXPORT QmlProfilerModelManager : public QObject
 {
@@ -94,9 +62,15 @@ public:
     ~QmlProfilerModelManager();
 
     State state() const;
-    QmlProfilerTraceTime *traceTime() const;
+
+    qint64 traceStart() const;
+    qint64 traceEnd() const;
+    qint64 traceDuration() const;
+    void decreaseTraceStart(qint64 start);
+    void increaseTraceEnd(qint64 end);
+
     QmlProfilerNotesModel *notesModel() const;
-    QmlProfilerTextMarkModel *textMarkModel() const;
+    Internal::QmlProfilerTextMarkModel *textMarkModel() const;
 
     bool isEmpty() const;
     uint numLoadedEvents() const;

src/plugins/qmlprofiler/qmlprofilerrangemodel.cpp

@@ -85,7 +85,7 @@ void QmlProfilerRangeModel::finalize()
 {
     if (!m_stack.isEmpty()) {
         qWarning() << "End times for some events are missing.";
-        const qint64 endTime = modelManager()->traceTime()->endTime();
+        const qint64 endTime = modelManager()->traceEnd();
         do {
             int index = m_stack.pop();
             insertEnd(index, endTime - startTime(index));

src/plugins/qmlprofiler/qmlprofilerstatewidget.cpp

@@ -126,7 +126,7 @@ void QmlProfilerStateWidget::updateDisplay()
     QmlProfilerModelManager::State state = d->m_modelManager->state();
     if (state == QmlProfilerModelManager::Done || state == QmlProfilerModelManager::Empty) {
         // After profiling, there is an empty trace
-        if (d->m_modelManager->traceTime()->duration() > 0 && d->m_modelManager->isEmpty()) {
+        if (d->m_modelManager->traceDuration() > 0 && d->m_modelManager->isEmpty()) {
             showText(tr("No QML events recorded"));
             return;
         }

src/plugins/qmlprofiler/qmlprofilerstatisticsmodel.cpp

@@ -104,8 +104,7 @@ void QmlProfilerStatisticsModel::restrictToFeatures(quint64 features)
 
     clear();
     beginResetModel();
-    if (!m_modelManager->replayEvents(m_modelManager->traceTime()->startTime(),
+    if (!m_modelManager->replayEvents(m_modelManager->traceStart(), m_modelManager->traceEnd(),
-                                       m_modelManager->traceTime()->endTime(),
                                       std::bind(&QmlProfilerStatisticsModel::loadEvent,
                                                 this, std::placeholders::_1,
                                                 std::placeholders::_2))) {

src/plugins/qmlprofiler/qmlprofilertool.cpp

@@ -486,7 +486,7 @@ void QmlProfilerTool::updateTimeDisplay()
     case QmlProfilerStateManager::Idle:
         if (d->m_profilerModelManager->state() != QmlProfilerModelManager::Empty &&
                d->m_profilerModelManager->state() != QmlProfilerModelManager::ClearingData)
-            seconds = d->m_profilerModelManager->traceTime()->duration() / 1.0e9;
+            seconds = d->m_profilerModelManager->traceDuration() / 1.0e9;
         break;
     }
     QString timeString = QString::number(seconds,'f',1);

src/plugins/qmlprofiler/qmlprofilertraceview.cpp

@@ -99,8 +99,8 @@ QmlProfilerTraceView::QmlProfilerTraceView(QWidget *parent, QmlProfilerViewManag
     connect(modelManager, &QmlProfilerModelManager::stateChanged, this, [modelManager, this]() {
         switch (modelManager->state()) {
         case QmlProfilerModelManager::Done: {
-            qint64 start = modelManager->traceTime()->startTime();
+            const qint64 start = modelManager->traceStart();
-            qint64 end = modelManager->traceTime()->endTime();
+            const qint64 end = modelManager->traceEnd();
             d->m_zoomControl->setTrace(start, end);
             d->m_zoomControl->setRange(start, start + (end - start) / 10);
             Q_FALLTHROUGH();

src/plugins/qmlprofiler/tests/pixmapcachemodel_test.cpp

@@ -38,8 +38,8 @@ PixmapCacheModelTest::PixmapCacheModelTest(QObject *parent) : QObject(parent),
 void PixmapCacheModelTest::initTestCase()
 {
     manager.startAcquiring();
-    manager.traceTime()->decreaseStartTime(1);
+    manager.decreaseTraceStart(1);
-    manager.traceTime()->increaseEndTime(300);
+    manager.increaseTraceEnd(300);
 
     for (int i = 0; i < MaximumPixmapEventType; ++i) {
         eventTypeIndices[i] = manager.numLoadedEventTypes();
@@ -208,9 +208,9 @@ void PixmapCacheModelTest::testConsistency()
 
         QVERIFY(model.startTime(i) >= currentTime);
         currentTime = model.startTime(i);
-        QVERIFY(currentTime >= manager.traceTime()->startTime());
+        QVERIFY(currentTime >= manager.traceStart());
         currentEnd = model.endTime(i);
-        QVERIFY(currentEnd <= manager.traceTime()->endTime());
+        QVERIFY(currentEnd <= manager.traceEnd());
 
         const QVariantMap details = model.details(i);