qt-everywhere-src-5.14.1/qtdeclarative/src/qmldebug/qqmlprofilerclient.cpp - orbit - Git at Google

 /****************************************************************************
 **
 ** 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$
 **
 ****************************************************************************/

 #include "qqmlprofilerclient_p_p.h"
 #include "qqmldebugconnection_p.h"

 QT_BEGIN_NAMESPACE

 QQmlProfilerClientPrivate::~QQmlProfilerClientPrivate()
 {
 }

 int QQmlProfilerClientPrivate::resolveType(const QQmlProfilerTypedEvent &event)
 {
     int typeIndex = -1;
     if (event.serverTypeId != 0) {
         QHash<qint64, int>::ConstIterator it = serverTypeIds.constFind(event.serverTypeId);

         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;
 }

 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 QQmlProfilerClientPrivate::forwardEvents(const QQmlProfilerEvent &last)
 {
     forwardDebugMessages(last.timestamp());
     eventReceiver->addEvent(last);
 }

 void QQmlProfilerClientPrivate::forwardDebugMessages(qint64 untilTimestamp)
 {
     while (!pendingDebugMessages.isEmpty()
            && pendingDebugMessages.front().timestamp() <= untilTimestamp) {
         eventReceiver->addEvent(pendingDebugMessages.dequeue());
     }
 }

 void QQmlProfilerClientPrivate::processCurrentEvent()
 {
     // 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())
             forwardEvents(currentEvent.event);
         else
             pendingMessages.enqueue(currentEvent.event);
         break;
     }
     }
 }

 void QQmlProfilerClientPrivate::sendRecordingStatus(int 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());
 }

 QQmlProfilerClient::QQmlProfilerClient(QQmlDebugConnection *connection,
                                        QQmlProfilerEventReceiver *eventReceiver,
                                        quint64 features)
     : QQmlDebugClient(*(new QQmlProfilerClientPrivate(connection, eventReceiver)))
 {
     Q_D(QQmlProfilerClient);
     setRequestedFeatures(features);
     connect(this, &QQmlDebugClient::stateChanged, this, &QQmlProfilerClient::onStateChanged);
     connect(d->engineControl.data(), &QQmlEngineControlClient::engineAboutToBeAdded,
             this, &QQmlProfilerClient::sendRecordingStatus);
     connect(d->engineControl.data(), &QQmlEngineControlClient::engineAboutToBeRemoved,
             this, [d](int engineId) {
         // We may already be done with that engine. Then we don't need to block it.
         if (d->trackedEngines.contains(engineId))
             d->engineControl->blockEngine(engineId);
     });
     connect(this, &QQmlProfilerClient::traceFinished,
             d->engineControl.data(), [d](qint64 timestamp, const QList<int> &engineIds) {
         Q_UNUSED(timestamp);
         // The engines might not be blocked because the trace can get finished before engine control
         // sees them.
         for (int blocked : d->engineControl->blockedEngines()) {
             if (engineIds.contains(blocked))
                 d->engineControl->releaseEngine(blocked);
         }
     });
 }

 QQmlProfilerClient::~QQmlProfilerClient()
 {
     //Disable profiling if started by client
     //Profiling data will be lost!!
     if (isRecording())
         setRecording(false);
 }

 void QQmlProfilerClient::clearEvents()
 {
     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::clearAll()
 {
     Q_D(QQmlProfilerClient);
     d->serverTypeIds.clear();
     d->eventTypeIds.clear();
     d->trackedEngines.clear();
     clearEvents();
 }

 void QQmlProfilerClientPrivate::finalize()
 {
     while (!rangesInProgress.isEmpty()) {
         currentEvent = rangesInProgress.top();
         currentEvent.event.setRangeStage(RangeEnd);
         currentEvent.event.setTimestamp(maximumTime);
         processCurrentEvent();
     }
     forwardDebugMessages(std::numeric_limits<qint64>::max());
 }


 void QQmlProfilerClient::sendRecordingStatus(int engineId)
 {
     Q_D(QQmlProfilerClient);
     d->sendRecordingStatus(engineId);
 }

 bool QQmlProfilerClient::isRecording() const
 {
     Q_D(const QQmlProfilerClient);
     return d->recording;
 }

 void QQmlProfilerClient::setRecording(bool v)
 {
     Q_D(QQmlProfilerClient);
     if (v == d->recording)
         return;

     d->recording = v;

     if (state() == Enabled)
         sendRecordingStatus();

     emit recordingChanged(v);
 }

 quint64 QQmlProfilerClient::recordedFeatures() const
 {
     Q_D(const QQmlProfilerClient);
     return d->recordedFeatures;
 }

 void QQmlProfilerClient::setRequestedFeatures(quint64 features)
 {
     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::setFlushInterval(quint32 flushInterval)
 {
     Q_D(QQmlProfilerClient);
     d->flushInterval = flushInterval;
 }

 QQmlProfilerClient::QQmlProfilerClient(QQmlProfilerClientPrivate &dd) :
     QQmlDebugClient(dd)
 {
     Q_D(QQmlProfilerClient);
     connect(d->engineControl.data(), &QQmlEngineControlClient::engineAboutToBeAdded,
             this, &QQmlProfilerClient::sendRecordingStatus);
 }

 bool QQmlProfilerClientPrivate::updateFeatures(ProfileFeature feature)
 {
     Q_Q(QQmlProfilerClient);
     quint64 flag = 1ULL << feature;
     if (!(requestedFeatures & flag))
         return false;
     if (!(recordedFeatures & flag)) {
         recordedFeatures |= flag;
         emit q->recordedFeaturesChanged(recordedFeatures);
     }
     return true;
 }

 void QQmlProfilerClient::onStateChanged(State status)
 {
     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);

     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) {
         const QList<int> engineIds = d->currentEvent.event.numbers<QList<int>, qint32>();
         d->trackedEngines.append(engineIds);
         d->forwardDebugMessages(d->currentEvent.event.timestamp());
         emit traceStarted(d->currentEvent.event.timestamp(), engineIds);
     } else if (d->currentEvent.type.message() == Event
                && d->currentEvent.type.detailType() == EndTrace) {
         const QList<int> engineIds = d->currentEvent.event.numbers<QList<int>, qint32>();
         for (int engineId : engineIds)
             d->trackedEngines.removeAll(engineId);
         d->forwardDebugMessages(d->currentEvent.event.timestamp());
         emit traceFinished(d->currentEvent.event.timestamp(), engineIds);
     } else if (d->updateFeatures(d->currentEvent.type.feature())) {
         d->processCurrentEvent();
     }
 }

 QT_END_NAMESPACE

 #include "moc_qqmlprofilerclient_p.cpp"
	/****************************************************************************
	**
	** 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$
	**
	****************************************************************************/

	#include "qqmlprofilerclient_p_p.h"
	#include "qqmldebugconnection_p.h"

	QT_BEGIN_NAMESPACE

	QQmlProfilerClientPrivate::~QQmlProfilerClientPrivate()
	{
	}

	int QQmlProfilerClientPrivate::resolveType(const QQmlProfilerTypedEvent &event)
	{
	int typeIndex = -1;
	if (event.serverTypeId != 0) {
	QHash<qint64, int>::ConstIterator it = serverTypeIds.constFind(event.serverTypeId);

	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;
	}

	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 QQmlProfilerClientPrivate::forwardEvents(const QQmlProfilerEvent &last)
	{
	forwardDebugMessages(last.timestamp());
	eventReceiver->addEvent(last);
	}

	void QQmlProfilerClientPrivate::forwardDebugMessages(qint64 untilTimestamp)
	{
	while (!pendingDebugMessages.isEmpty()
	&& pendingDebugMessages.front().timestamp() <= untilTimestamp) {
	eventReceiver->addEvent(pendingDebugMessages.dequeue());
	}
	}

	void QQmlProfilerClientPrivate::processCurrentEvent()
	{
	// 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())
	forwardEvents(currentEvent.event);
	else
	pendingMessages.enqueue(currentEvent.event);
	break;
	}
	}
	}

	void QQmlProfilerClientPrivate::sendRecordingStatus(int 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());
	}

	QQmlProfilerClient::QQmlProfilerClient(QQmlDebugConnection *connection,
	QQmlProfilerEventReceiver *eventReceiver,
	quint64 features)
	: QQmlDebugClient(*(new QQmlProfilerClientPrivate(connection, eventReceiver)))
	{
	Q_D(QQmlProfilerClient);
	setRequestedFeatures(features);
	connect(this, &QQmlDebugClient::stateChanged, this, &QQmlProfilerClient::onStateChanged);
	connect(d->engineControl.data(), &QQmlEngineControlClient::engineAboutToBeAdded,
	this, &QQmlProfilerClient::sendRecordingStatus);
	connect(d->engineControl.data(), &QQmlEngineControlClient::engineAboutToBeRemoved,
	this, [d](int engineId) {
	// We may already be done with that engine. Then we don't need to block it.
	if (d->trackedEngines.contains(engineId))
	d->engineControl->blockEngine(engineId);
	});
	connect(this, &QQmlProfilerClient::traceFinished,
	d->engineControl.data(), [d](qint64 timestamp, const QList<int> &engineIds) {
	Q_UNUSED(timestamp);
	// The engines might not be blocked because the trace can get finished before engine control
	// sees them.
	for (int blocked : d->engineControl->blockedEngines()) {
	if (engineIds.contains(blocked))
	d->engineControl->releaseEngine(blocked);
	}
	});
	}

	QQmlProfilerClient::~QQmlProfilerClient()
	{
	//Disable profiling if started by client
	//Profiling data will be lost!!
	if (isRecording())
	setRecording(false);
	}

	void QQmlProfilerClient::clearEvents()
	{
	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::clearAll()
	{
	Q_D(QQmlProfilerClient);
	d->serverTypeIds.clear();
	d->eventTypeIds.clear();
	d->trackedEngines.clear();
	clearEvents();
	}

	void QQmlProfilerClientPrivate::finalize()
	{
	while (!rangesInProgress.isEmpty()) {
	currentEvent = rangesInProgress.top();
	currentEvent.event.setRangeStage(RangeEnd);
	currentEvent.event.setTimestamp(maximumTime);
	processCurrentEvent();
	}
	forwardDebugMessages(std::numeric_limits<qint64>::max());
	}


	void QQmlProfilerClient::sendRecordingStatus(int engineId)
	{
	Q_D(QQmlProfilerClient);
	d->sendRecordingStatus(engineId);
	}

	bool QQmlProfilerClient::isRecording() const
	{
	Q_D(const QQmlProfilerClient);
	return d->recording;
	}

	void QQmlProfilerClient::setRecording(bool v)
	{
	Q_D(QQmlProfilerClient);
	if (v == d->recording)
	return;

	d->recording = v;

	if (state() == Enabled)
	sendRecordingStatus();

	emit recordingChanged(v);
	}

	quint64 QQmlProfilerClient::recordedFeatures() const
	{
	Q_D(const QQmlProfilerClient);
	return d->recordedFeatures;
	}

	void QQmlProfilerClient::setRequestedFeatures(quint64 features)
	{
	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::setFlushInterval(quint32 flushInterval)
	{
	Q_D(QQmlProfilerClient);
	d->flushInterval = flushInterval;
	}

	QQmlProfilerClient::QQmlProfilerClient(QQmlProfilerClientPrivate &dd) :
	QQmlDebugClient(dd)
	{
	Q_D(QQmlProfilerClient);
	connect(d->engineControl.data(), &QQmlEngineControlClient::engineAboutToBeAdded,
	this, &QQmlProfilerClient::sendRecordingStatus);
	}

	bool QQmlProfilerClientPrivate::updateFeatures(ProfileFeature feature)
	{
	Q_Q(QQmlProfilerClient);
	quint64 flag = 1ULL << feature;
	if (!(requestedFeatures & flag))
	return false;
	if (!(recordedFeatures & flag)) {
	recordedFeatures \|= flag;
	emit q->recordedFeaturesChanged(recordedFeatures);
	}
	return true;
	}

	void QQmlProfilerClient::onStateChanged(State status)
	{
	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);

	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) {
	const QList<int> engineIds = d->currentEvent.event.numbers<QList<int>, qint32>();
	d->trackedEngines.append(engineIds);
	d->forwardDebugMessages(d->currentEvent.event.timestamp());
	emit traceStarted(d->currentEvent.event.timestamp(), engineIds);
	} else if (d->currentEvent.type.message() == Event
	&& d->currentEvent.type.detailType() == EndTrace) {
	const QList<int> engineIds = d->currentEvent.event.numbers<QList<int>, qint32>();
	for (int engineId : engineIds)
	d->trackedEngines.removeAll(engineId);
	d->forwardDebugMessages(d->currentEvent.event.timestamp());
	emit traceFinished(d->currentEvent.event.timestamp(), engineIds);
	} else if (d->updateFeatures(d->currentEvent.type.feature())) {
	d->processCurrentEvent();
	}
	}

	QT_END_NAMESPACE

	#include "moc_qqmlprofilerclient_p.cpp"