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