Use better QmlProfiler client from Qt Creator

This client can track locations itself, and thus doesn't require the
server to send the event types over and over with each message. Once all
our client implementations have this feature we can drop a lot of code.

Furthermore, this way we can write regression tests for bugs that only
occur when client side location tracking is active.

Change-Id: I3735392452e20a7be98e92b900fadef04701d85f
Reviewed-by: Simon Hausmann <simon.hausmann@qt.io>

15 files changed, 1822 insertions, 329 deletions

diff --git a/src/qmldebug/qmldebug.pro b/src/qmldebug/qmldebug.pro
index e5f6de3314..2539414d8f 100644
--- a/src/qmldebug/qmldebug.pro
+++ b/src/qmldebug/qmldebug.pro
@@ -7,15 +7,25 @@ load(qt_module)
 SOURCES += \
     qqmldebugclient.cpp \
     qqmldebugconnection.cpp \
+    qqmldebugmessageclient.cpp \
     qqmlenginecontrolclient.cpp \
-    qqmlprofilerclient.cpp
+    qqmlprofilerclient.cpp \
+    qqmlprofilerevent.cpp \
+    qqmlprofilereventlocation.cpp \
+    qqmlprofilereventtype.cpp \
+    qqmlprofilertypedevent.cpp
 
 HEADERS += \
     qqmldebugclient_p.h \
     qqmldebugclient_p_p.h \
     qqmldebugconnection_p.h \
+    qqmldebugmessageclient_p.h \
     qqmlenginecontrolclient_p.h \
     qqmlenginecontrolclient_p_p.h \
-    qqmleventlocation_p.h \
     qqmlprofilerclient_p.h \
-    qqmlprofilerclient_p_p.h
+    qqmlprofilerclient_p_p.h \
+    qqmlprofilerevent_p.h \
+    qqmlprofilereventlocation_p.h \
+    qqmlprofilereventreceiver_p.h \
+    qqmlprofilereventtype_p.h \
+    qqmlprofilertypedevent_p.h
diff --git a/src/qmldebug/qqmldebugmessageclient.cpp b/src/qmldebug/qqmldebugmessageclient.cpp
new file mode 100644
index 0000000000..a03c1f8af2
--- /dev/null
+++ b/src/qmldebug/qqmldebugmessageclient.cpp
@@ -0,0 +1,95 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qqmldebugmessageclient_p.h"
+
+#include <QtCore/qdatastream.h>
+
+QT_BEGIN_NAMESPACE
+
+/*!
+  \class QQmlDebugMessageClient
+  \internal
+
+  \brief Client for the debug message service
+
+  The QQmlDebugMessageClient receives debug messages routed through the QML
+  debug connection via QDebugMessageService.
+ */
+
+QQmlDebugMessageClient::QQmlDebugMessageClient(QQmlDebugConnection *client)
+    : QQmlDebugClient(QLatin1String("DebugMessages"), client)
+{
+}
+
+void QQmlDebugMessageClient::stateChanged(State state)
+{
+    emit newState(state);
+}
+
+void QQmlDebugMessageClient::messageReceived(const QByteArray &data)
+{
+    QDataStream ds(data);
+    QByteArray command;
+    ds >> command;
+
+    if (command == "MESSAGE") {
+        int type;
+        int line;
+        QByteArray debugMessage;
+        QByteArray file;
+        QByteArray function;
+        ds >> type >> debugMessage >> file >> line >> function;
+        QQmlDebugContextInfo info;
+        info.line = line;
+        info.file = QString::fromUtf8(file);
+        info.function = QString::fromUtf8(function);
+        info.timestamp = -1;
+        if (!ds.atEnd()) {
+            QByteArray category;
+            ds >> category;
+            info.category = QString::fromUtf8(category);
+            if (!ds.atEnd())
+                ds >> info.timestamp;
+        }
+        emit message(QtMsgType(type), QString::fromUtf8(debugMessage), info);
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/qmldebug/qqmldebugmessageclient_p.h b/src/qmldebug/qqmldebugmessageclient_p.h
new file mode 100644
index 0000000000..75c70044e4
--- /dev/null
+++ b/src/qmldebug/qqmldebugmessageclient_p.h
@@ -0,0 +1,87 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQMLDEBUGMESSAGECLIENT_P_H
+#define QQMLDEBUGMESSAGECLIENT_P_H
+
+#include "qqmldebugclient_p.h"
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+QT_BEGIN_NAMESPACE
+
+struct QQmlDebugContextInfo
+{
+    int line;
+    QString file;
+    QString function;
+    QString category;
+    qint64 timestamp;
+};
+
+class QQmlDebugMessageClient : public QQmlDebugClient
+{
+    Q_OBJECT
+
+public:
+    explicit QQmlDebugMessageClient(QQmlDebugConnection *client);
+
+    virtual void stateChanged(State state) override;
+    virtual void messageReceived(const QByteArray &) override;
+
+signals:
+    void newState(QQmlDebugClient::State);
+    void message(QtMsgType, const QString &, const QQmlDebugContextInfo &);
+
+private:
+    Q_DISABLE_COPY(QQmlDebugMessageClient)
+};
+
+QT_END_NAMESPACE
+
+#endif // QQMLDEBUGMESSAGECLIENT_P_H
diff --git a/src/qmldebug/qqmlprofilerclient.cpp b/src/qmldebug/qqmlprofilerclient.cpp
index 3676bd933c..dca564cd76 100644
--- a/src/qmldebug/qqmlprofilerclient.cpp
+++ b/src/qmldebug/qqmlprofilerclient.cpp
@@ -43,337 +43,296 @@
 
 QT_BEGIN_NAMESPACE
 
-QQmlProfilerClient::QQmlProfilerClient(QQmlDebugConnection *connection) :
-    QQmlDebugClient(*(new QQmlProfilerClientPrivate(connection)))
+int QQmlProfilerClientPrivate::resolveType(const QQmlProfilerTypedEvent &event)
 {
-}
+    int typeIndex = -1;
+    if (event.serverTypeId != 0) {
+        QHash<qint64, int>::ConstIterator it = serverTypeIds.constFind(event.serverTypeId);
 
-QQmlProfilerClient::QQmlProfilerClient(QQmlProfilerClientPrivate &dd) :
-    QQmlDebugClient(dd)
-{
+        if (it != serverTypeIds.constEnd()) {
+            typeIndex = it.value();
+        } else {
+            typeIndex = eventReceiver->numLoadedEventTypes();
+            eventReceiver->addEventType(event.type);
+            serverTypeIds[event.serverTypeId] = typeIndex;
+        }
+    } else {
+        QHash<QQmlProfilerEventType, int>::ConstIterator it = eventTypeIds.constFind(event.type);
+
+        if (it != eventTypeIds.constEnd()) {
+            typeIndex = it.value();
+        } else {
+            typeIndex = eventReceiver->numLoadedEventTypes();
+            eventReceiver->addEventType(event.type);
+            eventTypeIds[event.type] = typeIndex;
+        }
+    }
+    return typeIndex;
 }
 
-QQmlProfilerClientPrivate::QQmlProfilerClientPrivate(QQmlDebugConnection *connection) :
-    QQmlDebugClientPrivate(QQmlProfilerService::s_key, connection),
-    features(std::numeric_limits<quint64>::max())
+int QQmlProfilerClientPrivate::resolveStackTop()
 {
+    if (rangesInProgress.isEmpty())
+        return -1;
+
+    QQmlProfilerTypedEvent &typedEvent = rangesInProgress.top();
+    int typeIndex = typedEvent.event.typeIndex();
+    if (typeIndex >= 0)
+        return typeIndex;
+
+    typeIndex = resolveType(typedEvent);
+    typedEvent.event.setTypeIndex(typeIndex);
+    while (!pendingMessages.isEmpty()
+           && pendingMessages.head().timestamp() < typedEvent.event.timestamp()) {
+        forwardEvents(pendingMessages.dequeue());
+    }
+    forwardEvents(typedEvent.event);
+    return typeIndex;
 }
 
-void QQmlProfilerClient::setFeatures(quint64 features)
+void QQmlProfilerClientPrivate::forwardEvents(const QQmlProfilerEvent &last)
 {
-    Q_D(QQmlProfilerClient);
-    d->features = features;
+    while (!pendingDebugMessages.isEmpty()
+           && pendingDebugMessages.front().timestamp() <= last.timestamp()) {
+        eventReceiver->addEvent(pendingDebugMessages.dequeue());
+    }
+    eventReceiver->addEvent(last);
 }
 
-void QQmlProfilerClient::sendRecordingStatus(bool record, int engineId, quint32 flushInterval)
+void QQmlProfilerClientPrivate::processCurrentEvent()
 {
-    Q_D(const QQmlProfilerClient);
-
-    QPacket stream(d->connection->currentDataStreamVersion());
-    stream << record << engineId << d->features << flushInterval << true;
-    sendMessage(stream.data());
+    // RangeData and RangeLocation always apply to the range on the top of the stack. Furthermore,
+    // all ranges are perfectly nested. This is why we can defer the type resolution until either
+    // the range ends or a child range starts. With only the information in RangeStart we wouldn't
+    // be able to uniquely identify the event type.
+    Message rangeStage = currentEvent.type.rangeType() == MaximumRangeType ?
+                currentEvent.type.message() : currentEvent.event.rangeStage();
+    switch (rangeStage) {
+    case RangeStart:
+        resolveStackTop();
+        rangesInProgress.push(currentEvent);
+        break;
+    case RangeEnd: {
+        int typeIndex = resolveStackTop();
+        if (typeIndex == -1)
+            break;
+        currentEvent.event.setTypeIndex(typeIndex);
+        while (!pendingMessages.isEmpty())
+            forwardEvents(pendingMessages.dequeue());
+        forwardEvents(currentEvent.event);
+        rangesInProgress.pop();
+        break;
+    }
+    case RangeData:
+        if (!rangesInProgress.isEmpty())
+            rangesInProgress.top().type.setData(currentEvent.type.data());
+        break;
+    case RangeLocation:
+        if (!rangesInProgress.isEmpty())
+            rangesInProgress.top().type.setLocation(currentEvent.type.location());
+        break;
+    case DebugMessage:
+        currentEvent.event.setTypeIndex(resolveType(currentEvent));
+        pendingDebugMessages.enqueue(currentEvent.event);
+        break;
+    default: {
+        int typeIndex = resolveType(currentEvent);
+        currentEvent.event.setTypeIndex(typeIndex);
+        if (rangesInProgress.isEmpty())
+            eventReceiver->addEvent(currentEvent.event);
+        else
+            pendingMessages.enqueue(currentEvent.event);
+        break;
+    }
+    }
 }
 
-void QQmlProfilerClient::traceStarted(qint64 time, int engineId)
+void QQmlProfilerClientPrivate::sendRecordingStatus(int engineId)
 {
-    Q_UNUSED(time);
-    Q_UNUSED(engineId);
+    Q_Q(QQmlProfilerClient);
+    QPacket stream(connection->currentDataStreamVersion());
+    stream << recording << engineId; // engineId -1 is OK. It means "all of them"
+    if (recording) {
+        stream << requestedFeatures << flushInterval;
+        stream << true; // yes, we support type IDs
+    }
+    q->sendMessage(stream.data());
 }
 
-void QQmlProfilerClient::traceFinished(qint64 time, int engineId)
+QQmlProfilerClient::QQmlProfilerClient(QQmlDebugConnection *connection,
+                                       QQmlProfilerEventReceiver *eventReceiver,
+                                       quint64 features)
+    : QQmlDebugClient(*(new QQmlProfilerClientPrivate(connection, eventReceiver)))
 {
-    Q_UNUSED(time);
-    Q_UNUSED(engineId);
+    Q_D(QQmlProfilerClient);
+    setRequestedFeatures(features);
+    connect(d->engineControl.data(), &QQmlEngineControlClient::engineAboutToBeAdded,
+            this, &QQmlProfilerClient::sendRecordingStatus);
 }
 
-void QQmlProfilerClient::rangeStart(QQmlProfilerDefinitions::RangeType type, qint64 startTime)
+QQmlProfilerClient::~QQmlProfilerClient()
 {
-    Q_UNUSED(type);
-    Q_UNUSED(startTime);
+    //Disable profiling if started by client
+    //Profiling data will be lost!!
+    if (isRecording())
+        setRecording(false);
 }
 
-void QQmlProfilerClient::rangeData(QQmlProfilerDefinitions::RangeType type, qint64 time,
-                                   const QString &data)
+void QQmlProfilerClient::clearEvents()
 {
-    Q_UNUSED(type);
-    Q_UNUSED(time);
-    Q_UNUSED(data);
+    Q_D(QQmlProfilerClient);
+    d->rangesInProgress.clear();
+    d->pendingMessages.clear();
+    d->pendingDebugMessages.clear();
+    if (d->recordedFeatures != 0) {
+        d->recordedFeatures = 0;
+        emit recordedFeaturesChanged(0);
+    }
+    emit cleared();
 }
 
-void QQmlProfilerClient::rangeLocation(QQmlProfilerDefinitions::RangeType type, qint64 time,
-                                       const QQmlEventLocation &location)
+void QQmlProfilerClient::clearAll()
 {
-    Q_UNUSED(type);
-    Q_UNUSED(time);
-    Q_UNUSED(location);
+    Q_D(QQmlProfilerClient);
+    d->serverTypeIds.clear();
+    d->eventTypeIds.clear();
+    clearEvents();
 }
 
-void QQmlProfilerClient::rangeEnd(QQmlProfilerDefinitions::RangeType type, qint64 endTime)
+void QQmlProfilerClientPrivate::finalize()
 {
-    Q_UNUSED(type);
-    Q_UNUSED(endTime);
+    while (!rangesInProgress.isEmpty()) {
+        currentEvent = rangesInProgress.top();
+        currentEvent.event.setRangeStage(RangeEnd);
+        currentEvent.event.setTimestamp(maximumTime);
+        processCurrentEvent();
+    }
+    while (!pendingDebugMessages.isEmpty())
+        eventReceiver->addEvent(pendingDebugMessages.dequeue());
 }
 
-void QQmlProfilerClient::animationFrame(qint64 time, int frameRate, int animationCount,
-                                        int threadId)
+
+void QQmlProfilerClient::sendRecordingStatus(int engineId)
 {
-    Q_UNUSED(time);
-    Q_UNUSED(frameRate);
-    Q_UNUSED(animationCount);
-    Q_UNUSED(threadId);
+    Q_D(QQmlProfilerClient);
+    d->sendRecordingStatus(engineId);
 }
 
-void QQmlProfilerClient::sceneGraphEvent(QQmlProfilerDefinitions::SceneGraphFrameType type,
-                                         qint64 time, qint64 numericData1, qint64 numericData2,
-                                         qint64 numericData3, qint64 numericData4,
-                                         qint64 numericData5)
+bool QQmlProfilerClient::isRecording() const
 {
-    Q_UNUSED(type);
-    Q_UNUSED(time);
-    Q_UNUSED(numericData1);
-    Q_UNUSED(numericData2);
-    Q_UNUSED(numericData3);
-    Q_UNUSED(numericData4);
-    Q_UNUSED(numericData5);
+    Q_D(const QQmlProfilerClient);
+    return d->recording;
 }
 
-void QQmlProfilerClient::pixmapCacheEvent(QQmlProfilerDefinitions::PixmapEventType type,
-                                          qint64 time, const QString &url, int numericData1,
-                                          int numericData2)
+void QQmlProfilerClient::setRecording(bool v)
 {
-    Q_UNUSED(type);
-    Q_UNUSED(time);
-    Q_UNUSED(url);
-    Q_UNUSED(numericData1);
-    Q_UNUSED(numericData2);
+    Q_D(QQmlProfilerClient);
+    if (v == d->recording)
+        return;
+
+    d->recording = v;
+
+    if (state() == Enabled)
+        sendRecordingStatus();
+
+    emit recordingChanged(v);
 }
 
-void QQmlProfilerClient::memoryAllocation(QQmlProfilerDefinitions::MemoryType type, qint64 time,
-                                          qint64 amount)
+quint64 QQmlProfilerClient::recordedFeatures() const
 {
-    Q_UNUSED(type);
-    Q_UNUSED(time);
-    Q_UNUSED(amount);
+    Q_D(const QQmlProfilerClient);
+    return d->recordedFeatures;
 }
 
-void QQmlProfilerClient::inputEvent(QQmlProfilerDefinitions::InputEventType type, qint64 time,
-                                    int a, int b)
+void QQmlProfilerClient::setRequestedFeatures(quint64 features)
 {
-    Q_UNUSED(type);
-    Q_UNUSED(time);
-    Q_UNUSED(a);
-    Q_UNUSED(b);
+    Q_D(QQmlProfilerClient);
+    d->requestedFeatures = features;
+    if (features & static_cast<quint64>(1) << ProfileDebugMessages) {
+        if (d->messageClient.isNull()) {
+            d->messageClient.reset(new QQmlDebugMessageClient(connection()));
+            connect(d->messageClient.data(), &QQmlDebugMessageClient::message, this,
+                    [this](QtMsgType type, const QString &text, const QQmlDebugContextInfo &context)
+            {
+                Q_D(QQmlProfilerClient);
+                d->updateFeatures(ProfileDebugMessages);
+                d->currentEvent.event.setTimestamp(context.timestamp > 0 ? context.timestamp : 0);
+                d->currentEvent.event.setTypeIndex(-1);
+                d->currentEvent.event.setString(text);
+                d->currentEvent.type = QQmlProfilerEventType(
+                            DebugMessage, MaximumRangeType, type,
+                            QQmlProfilerEventLocation(context.file, context.line, 1));
+                d->currentEvent.serverTypeId = 0;
+                d->processCurrentEvent();
+            });
+        }
+    } else {
+        d->messageClient.reset();
+    }
 }
 
-void QQmlProfilerClient::complete()
+void QQmlProfilerClient::setFlushInterval(quint32 flushInterval)
 {
+    Q_D(QQmlProfilerClient);
+    d->flushInterval = flushInterval;
 }
 
-void QQmlProfilerClient::unknownEvent(QQmlProfilerDefinitions::Message messageType, qint64 time,
-                                      int detailType)
+QQmlProfilerClient::QQmlProfilerClient(QQmlProfilerClientPrivate &dd) :
+    QQmlDebugClient(dd)
 {
-    Q_UNUSED(messageType);
-    Q_UNUSED(time);
-    Q_UNUSED(detailType);
+    Q_D(QQmlProfilerClient);
+    connect(d->engineControl.data(), &QQmlEngineControlClient::engineAboutToBeAdded,
+            this, &QQmlProfilerClient::sendRecordingStatus);
 }
 
-void QQmlProfilerClient::unknownData(QPacket &stream)
+bool QQmlProfilerClientPrivate::updateFeatures(ProfileFeature feature)
 {
-    Q_UNUSED(stream);
+    Q_Q(QQmlProfilerClient);
+    quint64 flag = 1ULL << feature;
+    if (!(requestedFeatures & flag))
+        return false;
+    if (!(recordedFeatures & flag)) {
+        recordedFeatures |= flag;
+        emit q->recordedFeaturesChanged(recordedFeatures);
+    }
+    return true;
 }
 
-inline QQmlProfilerDefinitions::ProfileFeature featureFromRangeType(
-        QQmlProfilerDefinitions::RangeType range)
+void QQmlProfilerClient::stateChanged(State status)
 {
-    switch (range) {
-        case QQmlProfilerDefinitions::Painting:
-            return QQmlProfilerDefinitions::ProfilePainting;
-        case QQmlProfilerDefinitions::Compiling:
-            return QQmlProfilerDefinitions::ProfileCompiling;
-        case QQmlProfilerDefinitions::Creating:
-            return QQmlProfilerDefinitions::ProfileCreating;
-        case QQmlProfilerDefinitions::Binding:
-            return QQmlProfilerDefinitions::ProfileBinding;
-        case QQmlProfilerDefinitions::HandlingSignal:
-            return QQmlProfilerDefinitions::ProfileHandlingSignal;
-        case QQmlProfilerDefinitions::Javascript:
-            return QQmlProfilerDefinitions::ProfileJavaScript;
-        default:
-            return QQmlProfilerDefinitions::MaximumProfileFeature;
+    if (status == Enabled) {
+        sendRecordingStatus(-1);
+    } else {
+        Q_D(QQmlProfilerClient);
+        d->finalize();
     }
+
 }
 
 void QQmlProfilerClient::messageReceived(const QByteArray &data)
 {
     Q_D(QQmlProfilerClient);
-
     QPacket stream(d->connection->currentDataStreamVersion(), data);
 
-    // Force all the 1 << <FLAG> expressions to be done in 64 bit, to silence some warnings
-    const quint64 one = static_cast<quint64>(1);
-
-    qint64 time;
-    int messageType;
-
-    stream >> time >> messageType;
-
-    if (messageType >= QQmlProfilerDefinitions::MaximumMessage) {
-        unknownEvent(static_cast<QQmlProfilerDefinitions::Message>(messageType), time, -1);
-        return;
+    stream >> d->currentEvent;
+
+    d->maximumTime = qMax(d->currentEvent.event.timestamp(), d->maximumTime);
+    if (d->currentEvent.type.message() == Complete) {
+        d->finalize();
+        emit complete(d->maximumTime);
+    } else if (d->currentEvent.type.message() == Event
+               && d->currentEvent.type.detailType() == StartTrace) {
+        emit traceStarted(d->currentEvent.event.timestamp(),
+                          d->currentEvent.event.numbers<QList<int>, qint32>());
+    } else if (d->currentEvent.type.message() == Event
+               && d->currentEvent.type.detailType() == EndTrace) {
+        emit traceFinished(d->currentEvent.event.timestamp(),
+                           d->currentEvent.event.numbers<QList<int>, qint32>());
+    } else if (d->updateFeatures(d->currentEvent.type.feature())) {
+        d->processCurrentEvent();
     }
-
-    if (messageType == QQmlProfilerDefinitions::Event) {
-        int type;
-        stream >> type;
-
-        QQmlProfilerDefinitions::EventType eventType =
-                static_cast<QQmlProfilerDefinitions::EventType>(type);
-
-        if (eventType == QQmlProfilerDefinitions::EndTrace) {
-            int engineId = -1;
-            if (!stream.atEnd())
-                stream >> engineId;
-            traceFinished(time, engineId);
-        } else if (eventType == QQmlProfilerDefinitions::AnimationFrame) {
-            if (!(d->features & one << QQmlProfilerDefinitions::ProfileAnimations))
-                return;
-
-            int frameRate, animationCount;
-            int threadId = 0;
-            stream >> frameRate >> animationCount;
-            if (!stream.atEnd())
-                stream >> threadId;
-
-            animationFrame(time, frameRate, animationCount, threadId);
-        } else if (type == QQmlProfilerDefinitions::StartTrace) {
-            int engineId = -1;
-            if (!stream.atEnd())
-                stream >> engineId;
-            traceStarted(time, engineId);
-        } else if (eventType == QQmlProfilerDefinitions::Key ||
-                   eventType == QQmlProfilerDefinitions::Mouse) {
-
-            if (!(d->features & one << QQmlProfilerDefinitions::ProfileInputEvents))
-                return;
-
-            int type;
-            if (!stream.atEnd()) {
-                stream >> type;
-            } else {
-                type = (eventType == QQmlProfilerDefinitions::Key) ?
-                            QQmlProfilerDefinitions::InputKeyUnknown :
-                            QQmlProfilerDefinitions::InputMouseUnknown;
-            }
-
-            int a = 0;
-            if (!stream.atEnd())
-                stream >> a;
-
-            int b = 0;
-            if (!stream.atEnd())
-                stream >> b;
-
-            inputEvent(static_cast<QQmlProfilerDefinitions::InputEventType>(type), time, a, b);
-        } else {
-            unknownEvent(QQmlProfilerDefinitions::Event, time, type);
-        }
-    } else if (messageType == QQmlProfilerDefinitions::Complete) {
-        complete();
-    } else if (messageType == QQmlProfilerDefinitions::SceneGraphFrame) {
-        if (!(d->features & one << QQmlProfilerDefinitions::ProfileSceneGraph))
-            return;
-
-        int type;
-        int count = 0;
-        qint64 params[5];
-
-        stream >> type;
-        while (!stream.atEnd())
-            stream >> params[count++];
-
-        while (count < 5)
-            params[count++] = 0;
-
-        sceneGraphEvent(static_cast<QQmlProfilerDefinitions::SceneGraphFrameType>(type), time,
-                        params[0], params[1], params[2], params[3], params[4]);
-    } else if (messageType == QQmlProfilerDefinitions::PixmapCacheEvent) {
-        if (!(d->features & one << QQmlProfilerDefinitions::ProfilePixmapCache))
-            return;
-
-        int type, param1 = 0, param2 = 0;
-        QString pixUrl;
-        stream >> type >> pixUrl;
-
-        QQmlProfilerDefinitions::PixmapEventType pixmapEventType =
-                static_cast<QQmlProfilerDefinitions::PixmapEventType>(type);
-
-        if (pixmapEventType == QQmlProfilerDefinitions::PixmapReferenceCountChanged ||
-                pixmapEventType == QQmlProfilerDefinitions::PixmapCacheCountChanged) {
-            stream >> param1;
-        } else if (pixmapEventType == QQmlProfilerDefinitions::PixmapSizeKnown) {
-            stream >> param1 >> param2;
-        }
-
-        pixmapCacheEvent(pixmapEventType, time, pixUrl, param1, param2);
-    } else if (messageType == QQmlProfilerDefinitions::MemoryAllocation) {
-        if (!(d->features & one << QQmlProfilerDefinitions::ProfileMemory))
-            return;
-        int type;
-        qint64 delta;
-        stream >> type >> delta;
-        memoryAllocation((QQmlProfilerDefinitions::MemoryType)type, time, delta);
-    } else {
-        int range;
-        stream >> range;
-
-        QQmlProfilerDefinitions::RangeType rangeType =
-                static_cast<QQmlProfilerDefinitions::RangeType>(range);
-
-        if (range >= QQmlProfilerDefinitions::MaximumRangeType ||
-                !(d->features & one << featureFromRangeType(rangeType)))
-            return;
-
-        qint64 typeId = 0;
-        if (messageType == QQmlProfilerDefinitions::RangeStart) {
-            rangeStart(rangeType, time);
-            if (!stream.atEnd()) {
-                stream >> typeId;
-                auto i = d->types.constFind(typeId);
-                if (i != d->types.constEnd()) {
-                    rangeLocation(rangeType, time, i->location);
-                    rangeData(rangeType, time, i->name);
-                }
-            }
-        } else if (messageType == QQmlProfilerDefinitions::RangeData) {
-            QString data;
-            stream >> data;
-            rangeData(rangeType, time, data);
-            if (!stream.atEnd()) {
-                stream >> typeId;
-                d->types[typeId].name = data;
-            }
-        } else if (messageType == QQmlProfilerDefinitions::RangeLocation) {
-            QQmlEventLocation location;
-            stream >> location.filename >> location.line;
-
-            if (!stream.atEnd())
-                stream >> location.column;
-
-            rangeLocation(rangeType, time, location);
-            if (!stream.atEnd()) {
-                stream >> typeId;
-                d->types[typeId].location = location;
-            }
-        } else if (messageType == QQmlProfilerDefinitions::RangeEnd) {
-            rangeEnd(rangeType, time);
-        } else {
-            unknownEvent(static_cast<QQmlProfilerDefinitions::Message>(messageType), time, range);
-        }
-    }
-
-    if (!stream.atEnd())
-        unknownData(stream);
 }
+
 QT_END_NAMESPACE
 
 #include "moc_qqmlprofilerclient_p.cpp"
diff --git a/src/qmldebug/qqmlprofilerclient_p.h b/src/qmldebug/qqmlprofilerclient_p.h
index a328cad26c..68a32a1a5a 100644
--- a/src/qmldebug/qqmlprofilerclient_p.h
+++ b/src/qmldebug/qqmlprofilerclient_p.h
@@ -41,7 +41,9 @@
 #define QQMLPROFILERCLIENT_P_H
 
 #include "qqmldebugclient_p.h"
-#include "qqmleventlocation_p.h"
+#include "qqmlprofilereventlocation_p.h"
+#include "qqmlprofilereventreceiver_p.h"
+
 #include <private/qqmlprofilerdefinitions_p.h>
 #include <private/qpacket_p.h>
 
@@ -59,52 +61,42 @@
 QT_BEGIN_NAMESPACE
 
 class QQmlProfilerClientPrivate;
-class QQmlProfilerClient : public QQmlDebugClient
+class QQmlProfilerClient : public QQmlDebugClient, public QQmlProfilerDefinitions
 {
     Q_OBJECT
     Q_DECLARE_PRIVATE(QQmlProfilerClient)
+    Q_PROPERTY(bool recording READ isRecording WRITE setRecording NOTIFY recordingChanged)
 
 public:
-    QQmlProfilerClient(QQmlDebugConnection *connection);
-    void setFeatures(quint64 features);
-    void sendRecordingStatus(bool record, int engineId = -1, quint32 flushInterval = 0);
-
-protected:
-    QQmlProfilerClient(QQmlProfilerClientPrivate &dd);
-
-private:
-    void messageReceived(const QByteArray &message) override;
+    QQmlProfilerClient(QQmlDebugConnection *connection, QQmlProfilerEventReceiver *eventReceiver,
+                       quint64 features = std::numeric_limits<quint64>::max());
+    ~QQmlProfilerClient();
 
-    virtual void traceStarted(qint64 time, int engineId);
-    virtual void traceFinished(qint64 time, int engineId);
+    bool isRecording() const;
+    void setRecording(bool);
+    quint64 recordedFeatures() const;
+    virtual void messageReceived(const QByteArray &) override;
+    virtual void stateChanged(State status) override;
 
-    virtual void rangeStart(QQmlProfilerDefinitions::RangeType type, qint64 startTime);
-    virtual void rangeData(QQmlProfilerDefinitions::RangeType type, qint64 time,
-                           const QString &data);
-    virtual void rangeLocation(QQmlProfilerDefinitions::RangeType type, qint64 time,
-                               const QQmlEventLocation &location);
-    virtual void rangeEnd(QQmlProfilerDefinitions::RangeType type, qint64 endTime);
+    void clearEvents();
+    void clearAll();
 
-    virtual void animationFrame(qint64 time, int frameRate, int animationCount, int threadId);
+    void sendRecordingStatus(int engineId = -1);
+    void setRequestedFeatures(quint64 features);
+    void setFlushInterval(quint32 flushInterval);
 
-    virtual void sceneGraphEvent(QQmlProfilerDefinitions::SceneGraphFrameType type, qint64 time,
-                                 qint64 numericData1, qint64 numericData2, qint64 numericData3,
-                                 qint64 numericData4, qint64 numericData5);
-
-    virtual void pixmapCacheEvent(QQmlProfilerDefinitions::PixmapEventType type, qint64 time,
-                                  const QString &url, int numericData1, int numericData2);
-
-    virtual void memoryAllocation(QQmlProfilerDefinitions::MemoryType type, qint64 time,
-                                  qint64 amount);
+protected:
+    QQmlProfilerClient(QQmlProfilerClientPrivate &dd);
 
-    virtual void inputEvent(QQmlProfilerDefinitions::InputEventType type, qint64 time, int a,
-                            int b);
+signals:
+    void complete(qint64 maximumTime);
+    void traceFinished(qint64 timestamp, const QList<int> &engineIds);
+    void traceStarted(qint64 timestamp, const QList<int> &engineIds);
 
-    virtual void complete();
+    void recordingChanged(bool arg);
+    void recordedFeaturesChanged(quint64 features);
 
-    virtual void unknownEvent(QQmlProfilerDefinitions::Message messageType, qint64 time,
-                              int detailType);
-    virtual void unknownData(QPacket &stream);
+    void cleared();
 };
 
 QT_END_NAMESPACE
diff --git a/src/qmldebug/qqmlprofilerclient_p_p.h b/src/qmldebug/qqmlprofilerclient_p_p.h
index 9c44113aa8..cf0145409a 100644
--- a/src/qmldebug/qqmlprofilerclient_p_p.h
+++ b/src/qmldebug/qqmlprofilerclient_p_p.h
@@ -40,8 +40,15 @@
 #ifndef QQMLPROFILERCLIENT_P_P_H
 #define QQMLPROFILERCLIENT_P_P_H
 
-#include "qqmlprofilerclient_p.h"
 #include "qqmldebugclient_p_p.h"
+#include "qqmldebugmessageclient_p.h"
+#include "qqmlenginecontrolclient_p.h"
+#include "qqmlprofilerclient_p.h"
+#include "qqmlprofilertypedevent_p.h"
+
+#include <private/qqmlprofilerdefinitions_p.h>
+
+#include <QtCore/qqueue.h>
 
 //
 //  W A R N I N G
@@ -56,20 +63,48 @@
 
 QT_BEGIN_NAMESPACE
 
-struct QQmlProfilerRangeType
-{
-    QQmlEventLocation location;
-    QString name;
-};
-
-class QQmlProfilerClientPrivate : public QQmlDebugClientPrivate
-{
+class QQmlProfilerClientPrivate : public QQmlDebugClientPrivate, public QQmlProfilerDefinitions {
     Q_DECLARE_PUBLIC(QQmlProfilerClient)
 public:
-    QQmlProfilerClientPrivate(QQmlDebugConnection *connection);
-    quint64 features;
+    QQmlProfilerClientPrivate(QQmlDebugConnection *connection,
+                              QQmlProfilerEventReceiver *eventReceiver)
+        : QQmlDebugClientPrivate(QLatin1String("CanvasFrameRate"), connection)
+        , eventReceiver(eventReceiver)
+        , engineControl(new QQmlEngineControlClient(connection))
+        , maximumTime(0)
+        , recording(false)
+        , requestedFeatures(0)
+        , recordedFeatures(0)
+        , flushInterval(0)
+    {
+    }
+
+    virtual ~QQmlProfilerClientPrivate() override {}
+
+    void sendRecordingStatus(int engineId);
+    bool updateFeatures(ProfileFeature feature);
+    int resolveType(const QQmlProfilerTypedEvent &type);
+    int resolveStackTop();
+    void forwardEvents(const QQmlProfilerEvent &last);
+    void processCurrentEvent();
+    void finalize();
+
+    QQmlProfilerEventReceiver *eventReceiver;
+    QScopedPointer<QQmlEngineControlClient> engineControl;
+    QScopedPointer<QQmlDebugMessageClient> messageClient;
+    qint64 maximumTime;
+    bool recording;
+    quint64 requestedFeatures;
+    quint64 recordedFeatures;
+    quint32 flushInterval;
 
-    QHash<qint64, QQmlProfilerRangeType> types;
+    // Reuse the same event, so that we don't have to constantly reallocate all the data.
+    QQmlProfilerTypedEvent currentEvent;
+    QHash<QQmlProfilerEventType, int> eventTypeIds;
+    QHash<qint64, int> serverTypeIds;
+    QStack<QQmlProfilerTypedEvent> rangesInProgress;
+    QQueue<QQmlProfilerEvent> pendingMessages;
+    QQueue<QQmlProfilerEvent> pendingDebugMessages;
 };
 
 QT_END_NAMESPACE
diff --git a/src/qmldebug/qqmlprofilerevent.cpp b/src/qmldebug/qqmlprofilerevent.cpp
new file mode 100644
index 0000000000..30ae1c79a1
--- /dev/null
+++ b/src/qmldebug/qqmlprofilerevent.cpp
@@ -0,0 +1,273 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qqmlprofilerevent_p.h"
+#include <QtCore/qdatastream.h>
+
+QT_BEGIN_NAMESPACE
+
+bool operator==(const QQmlProfilerEvent &event1, const QQmlProfilerEvent &event2)
+{
+    if (event1.timestamp() != event2.timestamp() || event1.typeIndex() != event2.typeIndex())
+        return false;
+
+    // This is not particularly efficient, but we also don't need to do this very often.
+    return event1.numbers<QVarLengthArray<qint64>>() == event2.numbers<QVarLengthArray<qint64>>();
+}
+
+bool operator!=(const QQmlProfilerEvent &event1, const QQmlProfilerEvent &event2)
+{
+    return !(event1 == event2);
+}
+
+enum SerializationType {
+    OneByte    = 0,
+    TwoByte    = 1,
+    FourByte   = 2,
+    EightByte  = 3,
+    TypeMask   = 0x3
+};
+
+enum SerializationTypeOffset {
+    TimestampOffset  = 0,
+    TypeIndexOffset  = 2,
+    DataLengthOffset = 4,
+    DataOffset       = 6
+};
+
+template<typename Number>
+static inline void readNumbers(QDataStream &stream, Number *data, quint16 length)
+{
+    for (quint16 i = 0; i != length; ++i)
+        stream >> data[i];
+}
+
+template<typename Number>
+static inline Number readNumber(QDataStream &stream, qint8 type)
+{
+    switch (type) {
+    case OneByte: {
+        qint8 value;
+        stream >> value;
+        return static_cast<Number>(value);
+    }
+    case TwoByte: {
+        qint16 value;
+        stream >> value;
+        return static_cast<Number>(value);
+    }
+    case FourByte: {
+        qint32 value;
+        stream >> value;
+        return static_cast<Number>(value);
+    }
+    case EightByte: {
+        qint64 value;
+        stream >> value;
+        return static_cast<Number>(value);
+    }
+    default:
+        Q_UNREACHABLE();
+        return 0;
+    }
+}
+
+QDataStream &operator>>(QDataStream &stream, QQmlProfilerEvent &event)
+{
+    qint8 type;
+    stream >> type;
+
+    event.m_timestamp = readNumber<qint64>(stream, (type >> TimestampOffset) & TypeMask);
+    event.m_typeIndex = readNumber<qint32>(stream, (type >> TypeIndexOffset) & TypeMask);
+    event.m_dataLength = readNumber<quint16>(stream, (type >> DataLengthOffset) & TypeMask);
+
+    uint bytesPerNumber = 1 << ((type >> DataOffset) & TypeMask);
+
+    if (event.m_dataLength * bytesPerNumber > sizeof(event.m_data)) {
+        event.m_dataType = static_cast<QQmlProfilerEvent::Type>((bytesPerNumber * 8)
+                                                                | QQmlProfilerEvent::External);
+        event.m_data.external = malloc(event.m_dataLength * bytesPerNumber);
+    } else {
+        event.m_dataType = static_cast<QQmlProfilerEvent::Type>(bytesPerNumber * 8);
+    }
+
+    switch (event.m_dataType) {
+    case QQmlProfilerEvent::Inline8Bit:
+        readNumbers<qint8>(stream, event.m_data.internal8bit, event.m_dataLength);
+        break;
+    case QQmlProfilerEvent::External8Bit:
+        readNumbers<qint8>(stream, static_cast<qint8 *>(event.m_data.external),
+                           event.m_dataLength);
+        break;
+    case QQmlProfilerEvent::Inline16Bit:
+        readNumbers<qint16>(stream, event.m_data.internal16bit, event.m_dataLength);
+        break;
+    case QQmlProfilerEvent::External16Bit:
+        readNumbers<qint16>(stream, static_cast<qint16 *>(event.m_data.external),
+                            event.m_dataLength);
+        break;
+    case QQmlProfilerEvent::Inline32Bit:
+        readNumbers<qint32>(stream, event.m_data.internal32bit, event.m_dataLength);
+        break;
+    case QQmlProfilerEvent::External32Bit:
+        readNumbers<qint32>(stream, static_cast<qint32 *>(event.m_data.external),
+                            event.m_dataLength);
+        break;
+    case QQmlProfilerEvent::Inline64Bit:
+        readNumbers<qint64>(stream, event.m_data.internal64bit, event.m_dataLength);
+        break;
+    case QQmlProfilerEvent::External64Bit:
+        readNumbers<qint64>(stream, static_cast<qint64 *>(event.m_data.external),
+                            event.m_dataLength);
+        break;
+    default:
+        Q_UNREACHABLE();
+        break;
+    }
+
+    return stream;
+}
+
+static inline qint8 minimumType(const QQmlProfilerEvent &event, quint16 length,
+                                quint16 origBitsPerNumber)
+{
+    qint8 type = OneByte;
+    bool ok = true;
+    for (quint16 i = 0; i < length;) {
+        if ((1 << type) == origBitsPerNumber / 8)
+            return type;
+        switch (type) {
+        case OneByte:
+            ok = (event.number<qint8>(i) == event.number<qint64>(i));
+            break;
+        case TwoByte:
+            ok = (event.number<qint16>(i) == event.number<qint64>(i));
+            break;
+        case FourByte:
+            ok = (event.number<qint32>(i) == event.number<qint64>(i));
+            break;
+        default:
+            // EightByte isn't possible, as (1 << type) == origBitsPerNumber / 8 then.
+            Q_UNREACHABLE();
+            break;
+        }
+
+        if (ok)
+            ++i;
+        else
+            ++type;
+    }
+    return type;
+}
+
+template<typename Number>
+static inline qint8 minimumType(Number number)
+{
+     if (static_cast<qint8>(number) == number)
+         return OneByte;
+     if (static_cast<qint16>(number) == number)
+         return TwoByte;
+     if (static_cast<qint32>(number) == number)
+         return FourByte;
+     return EightByte;
+}
+
+template<typename Number>
+static inline void writeNumbers(QDataStream &stream, const QQmlProfilerEvent &event, quint16 length)
+{
+    for (quint16 i = 0; i != length; ++i)
+        stream << event.number<Number>(i);
+}
+
+template<typename Number>
+static inline void writeNumber(QDataStream &stream, Number number, qint8 type)
+{
+    switch (type) {
+    case OneByte:
+        stream << static_cast<qint8>(number);
+        break;
+    case TwoByte:
+        stream << static_cast<qint16>(number);
+        break;
+    case FourByte:
+        stream << static_cast<qint32>(number);
+        break;
+    case EightByte:
+        stream << static_cast<qint64>(number);
+        break;
+    default:
+        Q_UNREACHABLE();
+        break;
+    }
+}
+
+QDataStream &operator<<(QDataStream &stream, const QQmlProfilerEvent &event)
+{
+    qint8 type = minimumType(event.m_timestamp); // << TimestampOffset;
+    type |= minimumType(event.m_typeIndex) << TypeIndexOffset;
+    type |= minimumType(event.m_dataLength) << DataLengthOffset;
+    type |= minimumType(event, event.m_dataLength, event.m_dataType) << DataOffset;
+    stream << type;
+
+    writeNumber(stream, event.m_timestamp, (type >> TimestampOffset) & TypeMask);
+    writeNumber(stream, event.m_typeIndex, (type >> TypeIndexOffset) & TypeMask);
+    writeNumber(stream, event.m_dataLength, (type >> DataLengthOffset) & TypeMask);
+
+    switch ((type >> DataOffset) & TypeMask) {
+    case OneByte:
+        writeNumbers<qint8>(stream, event, event.m_dataLength);
+        break;
+    case TwoByte:
+        writeNumbers<qint16>(stream, event, event.m_dataLength);
+        break;
+    case FourByte:
+        writeNumbers<qint32>(stream, event, event.m_dataLength);
+        break;
+    case EightByte:
+        writeNumbers<qint64>(stream, event, event.m_dataLength);
+        break;
+    default:
+        Q_UNREACHABLE();
+        break;
+    }
+
+    return stream;
+}
+
+QT_END_NAMESPACE
diff --git a/src/qmldebug/qqmlprofilerevent_p.h b/src/qmldebug/qqmlprofilerevent_p.h
new file mode 100644
index 0000000000..93562302e9
--- /dev/null
+++ b/src/qmldebug/qqmlprofilerevent_p.h
@@ -0,0 +1,355 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQMLPROFILEREVENT_P_H
+#define QQMLPROFILEREVENT_P_H
+
+#include <private/qqmlprofilerdefinitions_p.h>
+
+#include <QtCore/qstring.h>
+#include <QtCore/qbytearray.h>
+#include <QtCore/qvarlengtharray.h>
+#include <QtCore/qmetatype.h>
+
+#include <initializer_list>
+#include <type_traits>
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+QT_BEGIN_NAMESPACE
+
+struct QQmlProfilerEvent : public QQmlProfilerDefinitions {
+    QQmlProfilerEvent() :
+        m_timestamp(-1), m_typeIndex(-1), m_dataType(Inline8Bit), m_dataLength(0)
+    {}
+
+    template<typename Number>
+    QQmlProfilerEvent(qint64 timestamp, int typeIndex, std::initializer_list<Number> list)
+        : m_timestamp(timestamp), m_typeIndex(typeIndex)
+    {
+        assignNumbers<std::initializer_list<Number>, Number>(list);
+    }
+
+    QQmlProfilerEvent(qint64 timestamp, int typeIndex, const QString &data)
+        : m_timestamp(timestamp), m_typeIndex(typeIndex)
+    {
+        assignNumbers<QByteArray, qint8>(data.toUtf8());
+    }
+
+    template<typename Number>
+    QQmlProfilerEvent(qint64 timestamp, int typeIndex, const QVector<Number> &data)
+        : m_timestamp(timestamp), m_typeIndex(typeIndex)
+    {
+        assignNumbers<QVector<Number>, Number>(data);
+    }
+
+    QQmlProfilerEvent(const QQmlProfilerEvent &other)
+        : m_timestamp(other.m_timestamp), m_typeIndex(other.m_typeIndex),
+          m_dataType(other.m_dataType), m_dataLength(other.m_dataLength)
+    {
+        assignData(other);
+    }
+
+    QQmlProfilerEvent(QQmlProfilerEvent &&other)
+    {
+        memcpy(this, &other, sizeof(QQmlProfilerEvent));
+        other.m_dataType = Inline8Bit; // prevent dtor from deleting the pointer
+    }
+
+    QQmlProfilerEvent &operator=(const QQmlProfilerEvent &other)
+    {
+        if (this != &other) {
+            clearPointer();
+            m_timestamp = other.m_timestamp;
+            m_typeIndex = other.m_typeIndex;
+            m_dataType = other.m_dataType;
+            m_dataLength = other.m_dataLength;
+            assignData(other);
+        }
+        return *this;
+    }
+
+    QQmlProfilerEvent &operator=(QQmlProfilerEvent &&other)
+    {
+        if (this != &other) {
+            memcpy(this, &other, sizeof(QQmlProfilerEvent));
+            other.m_dataType = Inline8Bit;
+        }
+        return *this;
+    }
+
+    ~QQmlProfilerEvent()
+    {
+        clearPointer();
+    }
+
+    qint64 timestamp() const { return m_timestamp; }
+    void setTimestamp(qint64 timestamp) { m_timestamp = timestamp; }
+
+    int typeIndex() const { return m_typeIndex; }
+    void setTypeIndex(int typeIndex) { m_typeIndex = typeIndex; }
+
+    template<typename Number>
+    Number number(int i) const
+    {
+        // Trailing zeroes can be omitted, for example for SceneGraph events
+        if (i >= m_dataLength)
+            return 0;
+        switch (m_dataType) {
+        case Inline8Bit:
+            return m_data.internal8bit[i];
+QT_WARNING_PUSH
+QT_WARNING_DISABLE_GCC("-Warray-bounds") // Mingw 5.3 gcc doesn't get the type/length logic.
+        case Inline16Bit:
+            return m_data.internal16bit[i];
+        case Inline32Bit:
+            return m_data.internal32bit[i];
+        case Inline64Bit:
+            return m_data.internal64bit[i];
+QT_WARNING_POP
+        case External8Bit:
+            return static_cast<const qint8 *>(m_data.external)[i];
+        case External16Bit:
+            return static_cast<const qint16 *>(m_data.external)[i];
+        case External32Bit:
+            return static_cast<const qint32 *>(m_data.external)[i];
+        case External64Bit:
+            return static_cast<const qint64 *>(m_data.external)[i];
+        default:
+            return 0;
+        }
+    }
+
+    template<typename Number>
+    void setNumber(int i, Number number)
+    {
+        QVarLengthArray<Number> nums = numbers<QVarLengthArray<Number>, Number>();
+        int prevSize = nums.size();
+        if (i >= prevSize) {
+            nums.resize(i + 1);
+            // Fill with zeroes. We don't want to accidentally prevent squeezing.
+            while (prevSize < i)
+                nums[prevSize++] = 0;
+        }
+        nums[i] = number;
+        setNumbers<QVarLengthArray<Number>, Number>(nums);
+    }
+
+    template<typename Container, typename Number>
+    void setNumbers(const Container &numbers)
+    {
+        clearPointer();
+        assignNumbers<Container, Number>(numbers);
+    }
+
+    template<typename Number>
+    void setNumbers(std::initializer_list<Number> numbers)
+    {
+        setNumbers<std::initializer_list<Number>, Number>(numbers);
+    }
+
+    template<typename Container, typename Number = qint64>
+    Container numbers() const
+    {
+        Container container;
+        for (int i = 0; i < m_dataLength; ++i)
+            container.append(number<Number>(i));
+        return container;
+    }
+
+    QString string() const
+    {
+        switch (m_dataType) {
+        case External8Bit:
+            return QString::fromUtf8(static_cast<const char *>(m_data.external), m_dataLength);
+        case Inline8Bit:
+            return QString::fromUtf8(m_data.internalChar, m_dataLength);
+        default:
+            Q_UNREACHABLE();
+            return QString();
+        }
+    }
+
+    void setString(const QString &data)
+    {
+        clearPointer();
+        assignNumbers<QByteArray, char>(data.toUtf8());
+    }
+
+    Message rangeStage() const
+    {
+        Q_ASSERT(m_dataType == Inline8Bit);
+        return static_cast<Message>(m_data.internal8bit[0]);
+    }
+
+    void setRangeStage(Message stage)
+    {
+        clearPointer();
+        m_dataType = Inline8Bit;
+        m_dataLength = 1;
+        m_data.internal8bit[0] = stage;
+    }
+
+    bool isValid() const
+    {
+        return m_timestamp != -1;
+    }
+
+private:
+    enum Type: quint16 {
+        External = 1,
+        Inline8Bit = 8,
+        External8Bit = Inline8Bit | External,
+        Inline16Bit = 16,
+        External16Bit = Inline16Bit | External,
+        Inline32Bit = 32,
+        External32Bit = Inline32Bit | External,
+        Inline64Bit = 64,
+        External64Bit = Inline64Bit | External
+    };
+
+    qint64 m_timestamp;
+
+    static const int s_internalDataLength = 8;
+    union {
+        void  *external;
+        char   internalChar [s_internalDataLength];
+        qint8  internal8bit [s_internalDataLength];
+        qint16 internal16bit[s_internalDataLength / 2];
+        qint32 internal32bit[s_internalDataLength / 4];
+        qint64 internal64bit[s_internalDataLength / 8];
+    } m_data;
+
+    qint32 m_typeIndex;
+    Type m_dataType;
+    quint16 m_dataLength;
+
+    void assignData(const QQmlProfilerEvent &other)
+    {
+        if (m_dataType & External) {
+            uint length = m_dataLength * (other.m_dataType / 8);
+            m_data.external = malloc(length);
+            memcpy(m_data.external, other.m_data.external, length);
+        } else {
+            memcpy(&m_data, &other.m_data, sizeof(m_data));
+        }
+    }
+
+    template<typename Big, typename Small>
+    bool squeezable(Big source)
+    {
+        return static_cast<Small>(source) == source;
+    }
+
+    template<typename Container, typename Number>
+    typename std::enable_if<(sizeof(Number) > 1), bool>::type
+    squeeze(const Container &numbers)
+    {
+        typedef typename QIntegerForSize<sizeof(Number) / 2>::Signed Small;
+        foreach (Number item, numbers) {
+            if (!squeezable<Number, Small>(item))
+                return false;
+        }
+        assignNumbers<Container, Small>(numbers);
+        return true;
+    }
+
+    template<typename Container, typename Number>
+    typename std::enable_if<(sizeof(Number) <= 1), bool>::type
+    squeeze(const Container &)
+    {
+        return false;
+    }
+
+    template<typename Container, typename Number>
+    void assignNumbers(const Container &numbers)
+    {
+        Number *data;
+        m_dataLength = squeezable<size_t, quint16>(static_cast<size_t>(numbers.size())) ?
+                    static_cast<quint16>(numbers.size()) : std::numeric_limits<quint16>::max();
+        if (m_dataLength > sizeof(m_data) / sizeof(Number)) {
+            if (squeeze<Container, Number>(numbers))
+                return;
+            m_dataType = static_cast<Type>((sizeof(Number) * 8) | External);
+            m_data.external = malloc(m_dataLength * sizeof(Number));
+            data = static_cast<Number *>(m_data.external);
+        } else {
+            m_dataType = static_cast<Type>(sizeof(Number) * 8);
+            data = static_cast<Number *>(m_dataType & External ? m_data.external : &m_data);
+        }
+        quint16 i = 0;
+        for (Number item : numbers) {
+            if (i >= m_dataLength)
+                break;
+            data[i++] = item;
+        }
+    }
+
+    void clearPointer()
+    {
+        if (m_dataType & External)
+            free(m_data.external);
+    }
+
+    friend QDataStream &operator>>(QDataStream &stream, QQmlProfilerEvent &event);
+    friend QDataStream &operator<<(QDataStream &stream, const QQmlProfilerEvent &event);
+};
+
+bool operator==(const QQmlProfilerEvent &event1, const QQmlProfilerEvent &event2);
+bool operator!=(const QQmlProfilerEvent &event1, const QQmlProfilerEvent &event2);
+
+QDataStream &operator>>(QDataStream &stream, QQmlProfilerEvent &event);
+QDataStream &operator<<(QDataStream &stream, const QQmlProfilerEvent &event);
+
+Q_DECLARE_TYPEINFO(QQmlProfilerEvent, Q_MOVABLE_TYPE);
+
+QT_END_NAMESPACE
+
+Q_DECLARE_METATYPE(QQmlProfilerEvent)
+
+#endif // QQMLPROFILEREVENT_P_H
diff --git a/src/qmldebug/qqmlprofilereventlocation.cpp b/src/qmldebug/qqmlprofilereventlocation.cpp
new file mode 100644
index 0000000000..8be44c17a3
--- /dev/null
+++ b/src/qmldebug/qqmlprofilereventlocation.cpp
@@ -0,0 +1,56 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qqmlprofilereventlocation_p.h"
+
+#include <QtCore/qdatastream.h>
+
+QT_BEGIN_NAMESPACE
+
+QDataStream &operator>>(QDataStream &stream, QQmlProfilerEventLocation &location)
+{
+    return stream >> location.m_filename >> location.m_line >> location.m_column;
+}
+
+QDataStream &operator<<(QDataStream &stream, const QQmlProfilerEventLocation &location)
+{
+    return stream << location.m_filename << location.m_line << location.m_column;
+}
+
+QT_END_NAMESPACE
diff --git a/src/qmldebug/qqmlprofilereventlocation_p.h b/src/qmldebug/qqmlprofilereventlocation_p.h
new file mode 100644
index 0000000000..6f37eab14b
--- /dev/null
+++ b/src/qmldebug/qqmlprofilereventlocation_p.h
@@ -0,0 +1,121 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQMLPROFILEREVENTLOCATION_P_H
+#define QQMLPROFILEREVENTLOCATION_P_H
+
+#include <QtCore/qstring.h>
+#include <QtCore/qhash.h>
+#include <QtCore/qdatastream.h>
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+QT_BEGIN_NAMESPACE
+
+class QQmlProfilerEventLocation
+{
+public:
+    QQmlProfilerEventLocation() : m_line(-1),m_column(-1) {}
+    QQmlProfilerEventLocation(const QString &file, int lineNumber, int columnNumber) :
+        m_filename(file), m_line(lineNumber), m_column(columnNumber)
+    {}
+
+    void clear()
+    {
+        m_filename.clear();
+        m_line = m_column = -1;
+    }
+
+    bool isValid() const
+    {
+        return !m_filename.isEmpty();
+    }
+
+    QString filename() const { return m_filename; }
+    int line() const { return m_line; }
+    int column() const { return m_column; }
+
+private:
+    friend QDataStream &operator>>(QDataStream &stream, QQmlProfilerEventLocation &location);
+    friend QDataStream &operator<<(QDataStream &stream, const QQmlProfilerEventLocation &location);
+
+    QString m_filename;
+    int m_line;
+    int m_column;
+};
+
+inline bool operator==(const QQmlProfilerEventLocation &location1,
+                       const QQmlProfilerEventLocation &location2)
+{
+    // compare filename last as it's expensive.
+    return location1.line() == location2.line() && location1.column() == location2.column()
+            && location1.filename() == location2.filename();
+}
+
+inline bool operator!=(const QQmlProfilerEventLocation &location1,
+                       const QQmlProfilerEventLocation &location2)
+{
+    return !(location1 == location2);
+}
+
+inline uint qHash(const QQmlProfilerEventLocation &location)
+{
+    return qHash(location.filename())
+            ^ ((location.line() & 0xfff)                   // 12 bits of line number
+               | ((location.column() << 16) & 0xff0000));  // 8 bits of column
+
+}
+
+QDataStream &operator>>(QDataStream &stream, QQmlProfilerEventLocation &location);
+QDataStream &operator<<(QDataStream &stream, const QQmlProfilerEventLocation &location);
+
+Q_DECLARE_TYPEINFO(QQmlProfilerEventLocation, Q_MOVABLE_TYPE);
+
+QT_END_NAMESPACE
+
+#endif // QQMLPROFILEREVENTLOCATION_P_H
diff --git a/src/qmldebug/qqmlprofilereventreceiver_p.h b/src/qmldebug/qqmlprofilereventreceiver_p.h
new file mode 100644
index 0000000000..ee8e592858
--- /dev/null
+++ b/src/qmldebug/qqmlprofilereventreceiver_p.h
@@ -0,0 +1,63 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQMLPROFILEREVENTRECEIVER_P_H
+#define QQMLPROFILEREVENTRECEIVER_P_H
+
+#include "qqmlprofilerevent_p.h"
+#include "qqmlprofilereventtype_p.h"
+
+#include <QtCore/qobject.h>
+
+QT_BEGIN_NAMESPACE
+
+class QQmlProfilerEventReceiver : public QObject
+{
+    Q_OBJECT
+public:
+    QQmlProfilerEventReceiver(QObject *parent = nullptr) : QObject(parent) {}
+
+    virtual int numLoadedEventTypes() const = 0;
+    virtual void addEventType(const QQmlProfilerEventType &type) = 0;
+    virtual void addEvent(const QQmlProfilerEvent &event) = 0;
+};
+
+QT_END_NAMESPACE
+
+#endif // QQMLPROFILEREVENTRECEIVER_P_H
diff --git a/src/qmldebug/qqmlprofilereventtype.cpp b/src/qmldebug/qqmlprofilereventtype.cpp
new file mode 100644
index 0000000000..b0aad3fc5b
--- /dev/null
+++ b/src/qmldebug/qqmlprofilereventtype.cpp
@@ -0,0 +1,92 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qqmlprofilereventtype_p.h"
+
+#include <QtCore/qdatastream.h>
+
+QT_BEGIN_NAMESPACE
+
+QDataStream &operator>>(QDataStream &stream, QQmlProfilerEventType &type)
+{
+    quint8 message;
+    quint8 rangeType;
+    stream >> type.m_displayName >> type.m_data >> type.m_location >> message >> rangeType
+           >> type.m_detailType;
+    type.m_message = static_cast<QQmlProfilerDefinitions::Message>(message);
+    type.m_rangeType = static_cast<QQmlProfilerDefinitions::RangeType>(rangeType);
+    return stream;
+}
+
+QDataStream &operator<<(QDataStream &stream, const QQmlProfilerEventType &type)
+{
+    return stream << type.m_displayName << type.m_data << type.m_location
+                  << static_cast<quint8>(type.m_message) << static_cast<quint8>(type.m_rangeType)
+                  << type.m_detailType;
+}
+
+QQmlProfilerDefinitions::ProfileFeature QQmlProfilerEventType::feature() const
+{
+    switch (m_message) {
+    case Event: {
+        switch (m_detailType) {
+        case Mouse:
+        case Key:
+            return ProfileInputEvents;
+        case AnimationFrame:
+            return ProfileAnimations;
+        default:
+            return MaximumProfileFeature;
+        }
+    }
+    case PixmapCacheEvent:
+        return ProfilePixmapCache;
+    case SceneGraphFrame:
+        return ProfileSceneGraph;
+    case MemoryAllocation:
+        return ProfileMemory;
+    case DebugMessage:
+        return ProfileDebugMessages;
+    default:
+        return featureFromRangeType(m_rangeType);
+    }
+}
+
+
+QT_END_NAMESPACE
diff --git a/src/qmldebug/qqmlprofilereventtype_p.h b/src/qmldebug/qqmlprofilereventtype_p.h
new file mode 100644
index 0000000000..7bd67f9ca8
--- /dev/null
+++ b/src/qmldebug/qqmlprofilereventtype_p.h
@@ -0,0 +1,126 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQMLPROFILEREVENTTYPE_P_H
+#define QQMLPROFILEREVENTTYPE_P_H
+
+#include "qqmlprofilereventlocation_p.h"
+
+#include <private/qqmlprofilerdefinitions_p.h>
+
+#include <QtCore/qstring.h>
+#include <QtCore/qmetatype.h>
+#include <QtCore/qhash.h>
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+QT_BEGIN_NAMESPACE
+
+class QQmlProfilerEventType : public QQmlProfilerDefinitions {
+public:
+    QQmlProfilerEventType(Message message = MaximumMessage, RangeType rangeType = MaximumRangeType,
+                          int detailType = -1,
+                          const QQmlProfilerEventLocation &location = QQmlProfilerEventLocation(),
+                          const QString &data = QString(), const QString displayName = QString()) :
+        m_displayName(displayName), m_data(data), m_location(location), m_message(message),
+        m_rangeType(rangeType), m_detailType(detailType)
+    {}
+
+    void setDisplayName(const QString &displayName) { m_displayName = displayName; }
+    void setData(const QString &data) { m_data = data; }
+    void setLocation(const QQmlProfilerEventLocation &location) { m_location = location; }
+
+    ProfileFeature feature() const;
+    QString displayName() const { return m_displayName; }
+    QString data() const { return m_data; }
+    QQmlProfilerEventLocation location() const { return m_location; }
+    Message message() const { return m_message; }
+    RangeType rangeType() const { return m_rangeType; }
+    int detailType() const { return m_detailType; }
+
+private:
+    friend QDataStream &operator>>(QDataStream &stream, QQmlProfilerEventType &type);
+    friend QDataStream &operator<<(QDataStream &stream, const QQmlProfilerEventType &type);
+
+    QString m_displayName;
+    QString m_data;
+    QQmlProfilerEventLocation m_location;
+    Message m_message;
+    RangeType m_rangeType;
+    int m_detailType; // can be EventType, BindingType, PixmapEventType or SceneGraphFrameType
+};
+
+QDataStream &operator>>(QDataStream &stream, QQmlProfilerEventType &type);
+QDataStream &operator<<(QDataStream &stream, const QQmlProfilerEventType &type);
+
+inline uint qHash(const QQmlProfilerEventType &type)
+{
+    return qHash(type.location())
+            ^ (((type.message() << 12) & 0xf000)                               // 4 bits message
+               | ((type.rangeType() << 24) & 0xf000000)                        // 4 bits rangeType
+               | ((static_cast<uint>(type.detailType()) << 28) & 0xf0000000)); // 4 bits detailType
+}
+
+inline bool operator==(const QQmlProfilerEventType &type1, const QQmlProfilerEventType &type2)
+{
+    return type1.message() == type2.message() && type1.rangeType() == type2.rangeType()
+            && type1.detailType() == type2.detailType() && type1.location() == type2.location();
+}
+
+inline bool operator!=(const QQmlProfilerEventType &type1, const QQmlProfilerEventType &type2)
+{
+    return !(type1 == type2);
+}
+
+Q_DECLARE_TYPEINFO(QQmlProfilerEventType, Q_MOVABLE_TYPE);
+
+QT_END_NAMESPACE
+
+Q_DECLARE_METATYPE(QQmlProfilerEventType)
+
+#endif // QQMLPROFILEREVENTTYPE_P_H
diff --git a/src/qmldebug/qqmlprofilertypedevent.cpp b/src/qmldebug/qqmlprofilertypedevent.cpp
new file mode 100644
index 0000000000..9b00481e17
--- /dev/null
+++ b/src/qmldebug/qqmlprofilertypedevent.cpp
@@ -0,0 +1,226 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the QtQml module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** 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-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qqmlprofilertypedevent_p.h"
+#include <QtCore/qvarlengtharray.h>
+
+QT_BEGIN_NAMESPACE
+
+QDataStream &operator>>(QDataStream &stream, QQmlProfilerTypedEvent &event)
+{
+    qint64 time;
+    qint32 messageType;
+    qint32 subtype;
+
+    stream >> time >> messageType;
+
+    if (messageType < 0 || messageType > QQmlProfilerDefinitions::MaximumMessage)
+        messageType = QQmlProfilerDefinitions::MaximumMessage;
+
+    QQmlProfilerDefinitions::RangeType rangeType = QQmlProfilerDefinitions::MaximumRangeType;
+    if (!stream.atEnd()) {
+        stream >> subtype;
+        rangeType = static_cast<QQmlProfilerDefinitions::RangeType>(subtype);
+        if (rangeType < 0 || rangeType > QQmlProfilerDefinitions::MaximumRangeType)
+            rangeType = QQmlProfilerDefinitions::MaximumRangeType;
+    } else {
+        subtype = -1;
+    }
+
+    event.event.setTimestamp(time > 0 ? time : 0);
+    event.event.setTypeIndex(-1);
+    event.serverTypeId = 0;
+
+    switch (messageType) {
+    case QQmlProfilerDefinitions::Event: {
+        event.type = QQmlProfilerEventType(
+                    static_cast<QQmlProfilerDefinitions::Message>(messageType),
+                    QQmlProfilerDefinitions::MaximumRangeType, subtype);
+        switch (subtype) {
+        case QQmlProfilerDefinitions::StartTrace:
+        case QQmlProfilerDefinitions::EndTrace: {
+            QVarLengthArray<qint32> engineIds;
+            while (!stream.atEnd()) {
+                qint32 id;
+                stream >> id;
+                engineIds << id;
+            }
+            event.event.setNumbers<QVarLengthArray<qint32>, qint32>(engineIds);
+            break;
+        }
+        case QQmlProfilerDefinitions::AnimationFrame: {
+            qint32 frameRate, animationCount;
+            qint32 threadId;
+            stream >> frameRate >> animationCount;
+            if (!stream.atEnd())
+                stream >> threadId;
+            else
+                threadId = 0;
+
+            event.event.setNumbers<qint32>({frameRate, animationCount, threadId});
+            break;
+        }
+        case QQmlProfilerDefinitions::Mouse:
+        case QQmlProfilerDefinitions::Key:
+            int inputType = (subtype == QQmlProfilerDefinitions::Key
+                             ? QQmlProfilerDefinitions::InputKeyUnknown
+                             : QQmlProfilerDefinitions::InputMouseUnknown);
+            if (!stream.atEnd())
+                stream >> inputType;
+            qint32 a = -1;
+            if (!stream.atEnd())
+                stream >> a;
+            qint32 b = -1;
+            if (!stream.atEnd())
+                stream >> b;
+
+            event.event.setNumbers<qint32>({inputType, a, b});
+            break;
+        }
+
+        break;
+    }
+    case QQmlProfilerDefinitions::Complete: {
+        event.type = QQmlProfilerEventType(
+                    static_cast<QQmlProfilerDefinitions::Message>(messageType),
+                    QQmlProfilerDefinitions::MaximumRangeType, subtype);
+        break;
+    }
+    case QQmlProfilerDefinitions::SceneGraphFrame: {
+        QVarLengthArray<qint64> params;
+        qint64 param;
+
+        while (!stream.atEnd()) {
+            stream >> param;
+            params.push_back(param);
+        }
+
+        event.type = QQmlProfilerEventType(
+                    static_cast<QQmlProfilerDefinitions::Message>(messageType),
+                    QQmlProfilerDefinitions::MaximumRangeType, subtype);
+        event.event.setNumbers<QVarLengthArray<qint64>, qint64>(params);
+        break;
+    }
+    case QQmlProfilerDefinitions::PixmapCacheEvent: {
+        qint32 width = 0, height = 0, refcount = 0;
+        QString filename;
+        stream >> filename;
+        if (subtype == QQmlProfilerDefinitions::PixmapReferenceCountChanged
+                || subtype == QQmlProfilerDefinitions::PixmapCacheCountChanged) {
+            stream >> refcount;
+        } else if (subtype == QQmlProfilerDefinitions::PixmapSizeKnown) {
+            stream >> width >> height;
+            refcount = 1;
+        }
+
+        event.type = QQmlProfilerEventType(
+                    static_cast<QQmlProfilerDefinitions::Message>(messageType),
+                    QQmlProfilerDefinitions::MaximumRangeType, subtype,
+                    QQmlProfilerEventLocation(filename, 0, 0));
+        event.event.setNumbers<qint32>({width, height, refcount});
+        break;
+    }
+    case QQmlProfilerDefinitions::MemoryAllocation: {
+        qint64 delta;
+        stream >> delta;
+
+        event.type = QQmlProfilerEventType(
+                    static_cast<QQmlProfilerDefinitions::Message>(messageType),
+                    QQmlProfilerDefinitions::MaximumRangeType, subtype);
+        event.event.setNumbers<qint64>({delta});
+        break;
+    }
+    case QQmlProfilerDefinitions::RangeStart: {
+        if (!stream.atEnd()) {
+            qint64 typeId;
+            stream >> typeId;
+            if (stream.status() == QDataStream::Ok)
+                event.serverTypeId = typeId;
+            // otherwise it's the old binding type of 4 bytes
+        }
+
+        event.type = QQmlProfilerEventType(QQmlProfilerDefinitions::MaximumMessage, rangeType, -1);
+        event.event.setRangeStage(QQmlProfilerDefinitions::RangeStart);
+        break;
+    }
+    case QQmlProfilerDefinitions::RangeData: {
+        QString data;
+        stream >> data;
+
+        event.type = QQmlProfilerEventType(QQmlProfilerDefinitions::MaximumMessage, rangeType, -1,
+                                           QQmlProfilerEventLocation(), data);
+        event.event.setRangeStage(QQmlProfilerDefinitions::RangeData);
+        if (!stream.atEnd())
+            stream >> event.serverTypeId;
+        break;
+    }
+    case QQmlProfilerDefinitions::RangeLocation: {
+        QString filename;
+        qint32 line = 0;
+        qint32 column = 0;
+        stream >> filename >> line;
+
+        if (!stream.atEnd()) {
+            stream >> column;
+            if (!stream.atEnd())
+                stream >> event.serverTypeId;
+        }
+
+        event.type = QQmlProfilerEventType(QQmlProfilerDefinitions::MaximumMessage, rangeType, -1,
+                                           QQmlProfilerEventLocation(filename, line, column));
+        event.event.setRangeStage(QQmlProfilerDefinitions::RangeLocation);
+        break;
+    }
+    case QQmlProfilerDefinitions::RangeEnd: {
+        event.type = QQmlProfilerEventType(QQmlProfilerDefinitions::MaximumMessage, rangeType, -1);
+        event.event.setRangeStage(QQmlProfilerDefinitions::RangeEnd);
+        break;
+    }
+    default:
+        event.event.setNumbers<char>({});
+        event.type = QQmlProfilerEventType(
+                    static_cast<QQmlProfilerDefinitions::Message>(messageType),
+                    QQmlProfilerDefinitions::MaximumRangeType, subtype);
+        break;
+    }
+
+    return stream;
+}
+
+QT_END_NAMESPACE
diff --git a/src/qmldebug/qqmleventlocation_p.h b/src/qmldebug/qqmlprofilertypedevent_p.h
index c3a2b93f0f..e7e947f2ef 100644
--- a/src/qmldebug/qqmleventlocation_p.h
+++ b/src/qmldebug/qqmlprofilertypedevent_p.h
@@ -1,6 +1,6 @@
 /****************************************************************************
 **
-** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2017 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtQml module of the Qt Toolkit.
@@ -37,10 +37,13 @@
 **
 ****************************************************************************/
 
-#ifndef QQMLEVENTLOCATION_P_H
-#define QQMLEVENTLOCATION_P_H
+#ifndef QQMLPROFILERTYPEDEVENT_P_H
+#define QQMLPROFILERTYPEDEVENT_P_H
 
-#include <QtCore/qstring.h>
+#include "qqmlprofilerevent_p.h"
+#include "qqmlprofilereventtype_p.h"
+
+#include <QtCore/qdatastream.h>
 
 //
 //  W A R N I N G
@@ -55,19 +58,19 @@
 
 QT_BEGIN_NAMESPACE
 
-struct QQmlEventLocation
+struct QQmlProfilerTypedEvent
 {
-    QQmlEventLocation() : line(-1), column(-1) {}
-    QQmlEventLocation(const QString &file, int lineNumber, int columnNumber) :
-        filename(file), line(lineNumber), column(columnNumber) {}
-
-    QString filename;
-    int line;
-    int column;
+    QQmlProfilerEvent event;
+    QQmlProfilerEventType type;
+    qint64 serverTypeId = 0;
 };
 
-Q_DECLARE_TYPEINFO(QQmlEventLocation, Q_MOVABLE_TYPE);
+QDataStream &operator>>(QDataStream &stream, QQmlProfilerTypedEvent &event);
+
+Q_DECLARE_TYPEINFO(QQmlProfilerTypedEvent, Q_MOVABLE_TYPE);
 
 QT_END_NAMESPACE
 
-#endif // QQMLEVENTLOCATION_P_H
+Q_DECLARE_METATYPE(QQmlProfilerTypedEvent)
+
+#endif // QQMLPROFILERTYPEDEVENT_P_H