Tracing: Make sure we don't cast between different kinds of events

Add a classId to TraceEvent and TraceEventType and add is() and as()
methods that check for it.

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

4 files changed, 28 insertions, 12 deletions

diff --git a/src/plugins/qmlprofiler/qmlevent.h b/src/plugins/qmlprofiler/qmlevent.h
index 23a62cb643..3f999d419e 100644
--- a/src/plugins/qmlprofiler/qmlevent.h
+++ b/src/plugins/qmlprofiler/qmlevent.h
@@ -39,24 +39,26 @@
 namespace QmlProfiler {
 
 struct QmlEvent : public Timeline::TraceEvent {
-    QmlEvent() : m_dataType(Inline8Bit), m_dataLength(0) {}
+    static const qint32 staticClassId = 0x716d6c65; // 'qmle';
+
+    QmlEvent() : TraceEvent(staticClassId), m_dataType(Inline8Bit), m_dataLength(0) {}
 
     template<typename Number>
     QmlEvent(qint64 timestamp, int typeIndex, std::initializer_list<Number> list)
-        : TraceEvent(timestamp, typeIndex)
+        : TraceEvent(staticClassId, timestamp, typeIndex)
     {
         assignNumbers<std::initializer_list<Number>, Number>(list);
     }
 
     QmlEvent(qint64 timestamp, int typeIndex, const QString &data)
-        : TraceEvent(timestamp, typeIndex)
+        : TraceEvent(staticClassId, timestamp, typeIndex)
     {
         assignNumbers<QByteArray, qint8>(data.toUtf8());
     }
 
     template<typename Number>
     QmlEvent(qint64 timestamp, int typeIndex, const QVector<Number> &data)
-        : TraceEvent(timestamp, typeIndex)
+        : TraceEvent(staticClassId, timestamp, typeIndex)
     {
         assignNumbers<QVector<Number>, Number>(data);
     }
diff --git a/src/plugins/qmlprofiler/qmleventtype.cpp b/src/plugins/qmlprofiler/qmleventtype.cpp
index 9cb99c0081..88a3d6dd47 100644
--- a/src/plugins/qmlprofiler/qmleventtype.cpp
+++ b/src/plugins/qmlprofiler/qmleventtype.cpp
@@ -79,7 +79,7 @@ QDataStream &operator<<(QDataStream &stream, const QmlEventType &type)
 QmlEventType::QmlEventType(Message message, RangeType rangeType, int detailType,
                            const QmlEventLocation &location, const QString &data,
                            const QString displayName) :
-    TraceEventType(qmlFeatureFromType(message, rangeType, detailType)),
+    TraceEventType(staticClassId, qmlFeatureFromType(message, rangeType, detailType)),
     m_data(data), m_location(location), m_message(message),
     m_rangeType(rangeType), m_detailType(detailType)
 {
diff --git a/src/plugins/qmlprofiler/qmleventtype.h b/src/plugins/qmlprofiler/qmleventtype.h
index 6c3fc53e06..1e038e634e 100644
--- a/src/plugins/qmlprofiler/qmleventtype.h
+++ b/src/plugins/qmlprofiler/qmleventtype.h
@@ -37,6 +37,8 @@ namespace QmlProfiler {
 
 class QmlEventType : public Timeline::TraceEventType {
 public:
+    static const qint32 staticClassId = 0x716d6c74; // 'qmlt';
+
     QmlEventType(Message message = MaximumMessage, RangeType rangeType = MaximumRangeType,
                  int detailType = -1, const QmlEventLocation &location = QmlEventLocation(),
                  const QString &data = QString(), const QString displayName = QString());
diff --git a/src/plugins/qmlprofiler/qmlprofilermodelmanager.cpp b/src/plugins/qmlprofiler/qmlprofilermodelmanager.cpp
index c54c7f0981..2d02c10afd 100644
--- a/src/plugins/qmlprofiler/qmlprofilermodelmanager.cpp
+++ b/src/plugins/qmlprofiler/qmlprofilermodelmanager.cpp
@@ -148,8 +148,9 @@ void QmlProfilerModelManager::registerFeatures(quint64 features, QmlEventLoader
 {
     const TraceEventLoader traceEventLoader = eventLoader ? [eventLoader](
             const Timeline::TraceEvent &event, const Timeline::TraceEventType &type) {
-        return eventLoader(static_cast<const QmlEvent &>(event),
-                           static_cast<const QmlEventType &>(type));
+        QTC_ASSERT(event.is<QmlEvent>(), return);
+        QTC_ASSERT(type.is<QmlEventType>(), return);
+        eventLoader(event.asConstRef<QmlEvent>(), type.asConstRef<QmlEventType>());
     } : TraceEventLoader();
 
     Timeline::TimelineTraceManager::registerFeatures(features, traceEventLoader, initializer,
@@ -158,7 +159,10 @@ void QmlProfilerModelManager::registerFeatures(quint64 features, QmlEventLoader
 
 const QmlEventType &QmlProfilerModelManager::eventType(int typeId) const
 {
-    return static_cast<const QmlEventType &>(TimelineTraceManager::eventType(typeId));
+    static const QmlEventType invalid;
+    const Timeline::TraceEventType &type = TimelineTraceManager::eventType(typeId);
+    QTC_ASSERT(type.is<QmlEventType>(), return invalid);
+    return type.asConstRef<QmlEventType>();
 }
 
 void QmlProfilerModelManager::replayEvents(TraceEventLoader loader, Initializer initializer,
@@ -190,7 +194,8 @@ void QmlProfilerModelManager::replayQmlEvents(QmlEventLoader loader,
         if (future.isCanceled())
             return false;
 
-        loader(static_cast<QmlEvent &&>(event), eventType(event.typeIndex()));
+        QTC_ASSERT(event.is<QmlEvent>(), return false);
+        loader(event.asRvalueRef<QmlEvent>(), eventType(event.typeIndex()));
         return true;
     });
 
@@ -462,13 +467,19 @@ void QmlProfilerEventTypeStorage::set(int typeId, Timeline::TraceEventType &&typ
     const size_t index = static_cast<size_t>(typeId);
     if (m_types.size() <= index)
         m_types.resize(index + 1);
-    m_types[index] = std::move(static_cast<QmlEventType &&>(type));
+    QTC_ASSERT(type.is<QmlEventType>(), return);
+    m_types[index] = std::move(type.asRvalueRef<QmlEventType>());
 }
 
 int QmlProfilerEventTypeStorage::append(Timeline::TraceEventType &&type)
 {
     const size_t index = m_types.size();
-    m_types.push_back(std::move(static_cast<QmlEventType &&>(type)));
+    if (type.is<QmlEventType>()) {
+        m_types.push_back(std::move(type.asRvalueRef<QmlEventType>()));
+    } else {
+        QTC_CHECK(false);
+        m_types.push_back(QmlEventType());
+    }
     QTC_ASSERT(index <= std::numeric_limits<int>::max(), return std::numeric_limits<int>::max());
     return static_cast<int>(index);
 }
@@ -495,7 +506,8 @@ QmlProfilerEventStorage::QmlProfilerEventStorage(
 
 int QmlProfilerEventStorage::append(Timeline::TraceEvent &&event)
 {
-    m_file.append(std::move(static_cast<QmlEvent &&>(event)));
+    QTC_ASSERT(event.is<QmlEvent>(), return m_size);
+    m_file.append(std::move(event.asRvalueRef<QmlEvent>()));
     return m_size++;
 }