Merge branch 'dev' of ssh://codereview.qt-project.org/qt/qtdeclarative into wip/v4

Conflicts:
	src/imports/qtquick2/plugins.qmltypes
	src/qml/debugger/qv8debugservice.cpp
	src/qml/qml/qml.pri
	src/qml/qml/qqmlcompiler.cpp
	src/qml/qml/qqmlcomponent.cpp
	src/qml/qml/qqmlcontext.cpp
	src/qml/qml/qqmldata_p.h
	src/qml/qml/qqmlengine_p.h
	src/qml/qml/qqmljavascriptexpression.cpp
	src/qml/qml/qqmlxmlhttprequest.cpp
	src/qml/qml/v4/qv4bindings.cpp
	src/qml/qml/v4/qv4irbuilder.cpp
	src/qml/qml/v4/qv4jsonobject_p.h
	src/qml/qml/v8/qqmlbuiltinfunctions.cpp
	src/qml/qml/v8/qv8bindings.cpp
	src/qml/qml/v8/qv8contextwrapper.cpp
	src/qml/qml/v8/qv8listwrapper.cpp
	src/qml/qml/v8/qv8qobjectwrapper.cpp
	src/qml/qml/v8/qv8qobjectwrapper_p.h
	src/qml/qml/v8/qv8sequencewrapper_p_p.h
	src/qml/qml/v8/qv8typewrapper.cpp
	src/qml/qml/v8/qv8valuetypewrapper.cpp
	src/qml/types/qqmldelegatemodel.cpp
	src/quick/items/context2d/qquickcanvasitem.cpp
	src/quick/items/context2d/qquickcontext2d.cpp
	sync.profile
	tests/auto/qml/qjsengine/tst_qjsengine.cpp
	tests/benchmarks/qml/animation/animation.pro
	tools/qmlprofiler/qmlprofiler.pro

Change-Id: I18a76b8a81d87523247fa03a44ca334b1a2360c9

6 files changed, 233 insertions, 45 deletions

diff --git a/src/qml/debugger/qqmldebugserver.cpp b/src/qml/debugger/qqmldebugserver.cpp
index 27e3d226cd..53ad15775c 100644
--- a/src/qml/debugger/qqmldebugserver.cpp
+++ b/src/qml/debugger/qqmldebugserver.cpp
@@ -102,9 +102,8 @@ public:
     bool gotHello;
     bool blockingMode;
 
-    QMutex messageArrivedMutex;
-    QWaitCondition messageArrivedCondition;
-    QStringList waitingForMessageNames;
+    QMutex helloMutex;
+    QWaitCondition helloCondition;
     QQmlDebugServerThread *thread;
     QPluginLoader loader;
     QAtomicInt changeServiceStateCalls;
@@ -298,6 +297,7 @@ QQmlDebugServer *QQmlDebugServer::instance()
             for (; argsIt != argsItEnd; ++argsIt) {
                 const QString strArgument = *argsIt;
                 if (strArgument.startsWith(QLatin1String("port:"))) {
+                    pluginName = QLatin1String("qmldbg_tcp");
                     portFrom = strArgument.mid(5).toInt(&ok);
                     portTo = portFrom;
                     QStringList::const_iterator argsNext = argsIt + 1;
@@ -308,7 +308,6 @@ QQmlDebugServer *QQmlDebugServer::instance()
                         portTo = nextArgument.toInt(&ok);
                         ++argsIt;
                     }
-                    pluginName = QLatin1String("qmldbg_tcp");
                 } else if (strArgument.startsWith(QLatin1String("host:"))) {
                     hostAddress = strArgument.mid(5);
                 } else if (strArgument == QLatin1String("block")) {
@@ -331,11 +330,11 @@ QQmlDebugServer *QQmlDebugServer::instance()
                 QQmlDebugServerPrivate *d = qQmlDebugServer->d_func();
                 d->blockingMode = block;
 
-                QMutexLocker locker(&d->messageArrivedMutex);
+                QMutexLocker locker(&d->helloMutex);
                 thread->start();
 
                 if (d->blockingMode)
-                    d->messageArrivedCondition.wait(&d->messageArrivedMutex);
+                    d->helloCondition.wait(&d->helloMutex);
 
             } else {
                 qWarning() << QString(QLatin1String(
@@ -418,10 +417,13 @@ void QQmlDebugServer::receiveMessage(const QByteArray &message)
                 if (s_dataStreamVersion > QDataStream().version())
                     s_dataStreamVersion = QDataStream().version();
             }
+
             // Send the hello answer immediately, since it needs to arrive before
             // the plugins below start sending messages.
+
             QByteArray helloAnswer;
             {
+                QReadLocker readPluginsLock(&d->pluginsLock);
                 QQmlDebugStream out(&helloAnswer, QIODevice::WriteOnly);
                 QStringList pluginNames;
                 QList<float> pluginVersions;
@@ -447,7 +449,8 @@ void QQmlDebugServer::receiveMessage(const QByteArray &message)
                 d->_q_changeServiceState(iter.value()->name(), newState);
             }
 
-            d->messageArrivedCondition.wakeAll();
+            QMutexLocker helloLock(&d->helloMutex);
+            d->helloCondition.wakeAll();
 
         } else if (op == 1) {
 
@@ -487,9 +490,6 @@ void QQmlDebugServer::receiveMessage(const QByteArray &message)
                 qWarning() << "QML Debugger: Message received for missing plugin" << name << '.';
             } else {
                 (*iter)->messageReceived(message);
-
-                if (d->waitingForMessageNames.removeOne(name))
-                    d->messageArrivedCondition.wakeAll();
             }
         } else {
             qWarning("QML Debugger: Invalid hello message.");
diff --git a/src/qml/debugger/qqmldebugserver_p.h b/src/qml/debugger/qqmldebugserver_p.h
index 27d54d6947..e285d7cfe7 100644
--- a/src/qml/debugger/qqmldebugserver_p.h
+++ b/src/qml/debugger/qqmldebugserver_p.h
@@ -71,8 +71,6 @@ public:
 
     static QQmlDebugServer *instance();
 
-    void setConnection(QQmlDebugServerConnection *connection);
-
     bool hasDebuggingClient() const;
     bool blockingMode() const;
 
diff --git a/src/qml/debugger/qqmlprofilerservice.cpp b/src/qml/debugger/qqmlprofilerservice.cpp
index cb85fc0e1f..0ba939cdca 100644
--- a/src/qml/debugger/qqmlprofilerservice.cpp
+++ b/src/qml/debugger/qqmlprofilerservice.cpp
@@ -55,7 +55,7 @@ QT_BEGIN_NAMESPACE
 // instance will be set, unset in constructor. Allows static methods to be inlined.
 QQmlProfilerService *QQmlProfilerService::instance = 0;
 Q_GLOBAL_STATIC(QQmlProfilerService, profilerInstance)
-
+bool QQmlProfilerService::enabled = false;
 
 // convert to a QByteArray that can be sent to the debug client
 // use of QDataStream can skew results
@@ -76,12 +76,46 @@ QByteArray QQmlProfilerData::toByteArray() const
     if (messageType == (int)QQmlProfilerService::Event &&
             detailType == (int)QQmlProfilerService::AnimationFrame)
         ds << framerate << animationcount;
+    if (messageType == (int)QQmlProfilerService::PixmapCacheEvent) {
+        ds << detailData;
+        switch (detailType) {
+        case QQmlProfilerService::PixmapSizeKnown: ds << line << column; break;
+        case QQmlProfilerService::PixmapReferenceCountChanged: ds << animationcount; break;
+        case QQmlProfilerService::PixmapCacheCountChanged: ds << animationcount; break;
+        default: break;
+        }
+    }
+    if (messageType == (int)QQmlProfilerService::SceneGraphFrame) {
+        switch (detailType) {
+        // RendererFrame: preprocessTime, updateTime, bindingTime, renderTime
+        case QQmlProfilerService::SceneGraphRendererFrame: ds << subtime_1 << subtime_2 << subtime_3 << subtime_4; break;
+        // AdaptationLayerFrame: glyphCount (which is an integer), glyphRenderTime, glyphStoreTime
+        case QQmlProfilerService::SceneGraphAdaptationLayerFrame: ds << (int)subtime_1 << subtime_2 << subtime_3; break;
+        // ContextFrame: compiling material time
+        case QQmlProfilerService::SceneGraphContextFrame: ds << subtime_1; break;
+        // RenderLoop: syncTime, renderTime, swapTime
+        case QQmlProfilerService::SceneGraphRenderLoopFrame: ds << subtime_1 << subtime_2 << subtime_3; break;
+        // TexturePrepare: bind, convert, swizzle, upload, mipmap
+        case QQmlProfilerService::SceneGraphTexturePrepare: ds << subtime_1 << subtime_2 << subtime_3 << subtime_4 << subtime_5; break;
+        // TextureDeletion: deletionTime
+        case QQmlProfilerService::SceneGraphTextureDeletion: ds << subtime_1; break;
+        // PolishAndSync: polishTime, waitTime, syncTime, animationsTime,
+        case QQmlProfilerService::SceneGraphPolishAndSync: ds << subtime_1 << subtime_2 << subtime_3 << subtime_4; break;
+        // WindowsRenderLoop: GL time, make current time, SceneGraph time
+        case QQmlProfilerService::SceneGraphWindowsRenderShow: ds << subtime_1 << subtime_2 << subtime_3; break;
+        // WindowsAnimations: update time
+        case QQmlProfilerService::SceneGraphWindowsAnimations: ds << subtime_1; break;
+        // WindowsRenderWindow: polish time
+        case QQmlProfilerService::SceneGraphWindowsPolishFrame: ds << subtime_1; break;
+        default:break;
+        }
+    }
+
     return data;
 }
 
 QQmlProfilerService::QQmlProfilerService()
-    : QQmlDebugService(QStringLiteral("CanvasFrameRate"), 1),
-      m_enabled(false)
+    : QQmlDebugService(QStringLiteral("CanvasFrameRate"), 1)
 {
     m_timer.start();
 
@@ -131,6 +165,11 @@ void QQmlProfilerService::animationFrame(qint64 delta)
     profilerInstance()->animationFrameImpl(delta);
 }
 
+void QQmlProfilerService::sceneGraphFrame(SceneGraphFrameType frameType, qint64 value1, qint64 value2, qint64 value3, qint64 value4, qint64 value5)
+{
+    profilerInstance()->sceneGraphFrameImpl(frameType, value1, value2, value3, value4, value5);
+}
+
 void QQmlProfilerService::sendProfilingData()
 {
     profilerInstance()->sendMessages();
@@ -160,88 +199,136 @@ bool QQmlProfilerService::stopProfilingImpl()
 
 void QQmlProfilerService::sendStartedProfilingMessageImpl()
 {
-    if (!QQmlDebugService::isDebuggingEnabled() || !m_enabled)
+    if (!QQmlDebugService::isDebuggingEnabled() || !enabled)
         return;
 
     QQmlProfilerData ed = {m_timer.nsecsElapsed(), (int)Event, (int)StartTrace,
-                           QString(), -1, -1, 0, 0, 0};
+                           QString(), -1, -1, 0, 0, 0,
+                           0, 0, 0, 0, 0};
     QQmlDebugService::sendMessage(ed.toByteArray());
 }
 
 void QQmlProfilerService::addEventImpl(EventType event)
 {
-    if (!QQmlDebugService::isDebuggingEnabled() || !m_enabled)
+    if (!QQmlDebugService::isDebuggingEnabled() || !enabled)
         return;
 
     QQmlProfilerData ed = {m_timer.nsecsElapsed(), (int)Event, (int)event,
-                           QString(), -1, -1, 0, 0, 0};
+                           QString(), -1, -1, 0, 0, 0,
+                           0, 0, 0, 0, 0};
     processMessage(ed);
 }
 
 void QQmlProfilerService::startRange(RangeType range, BindingType bindingType)
 {
-    if (!QQmlDebugService::isDebuggingEnabled() || !m_enabled)
+    if (!QQmlDebugService::isDebuggingEnabled() || !enabled)
         return;
 
     QQmlProfilerData rd = {m_timer.nsecsElapsed(), (int)RangeStart, (int)range,
-                           QString(), -1, -1, 0, 0, (int)bindingType};
+                           QString(), -1, -1, 0, 0, (int)bindingType,
+                           0, 0, 0, 0, 0};
     processMessage(rd);
 }
 
 void QQmlProfilerService::rangeData(RangeType range, const QString &rData)
 {
-    if (!QQmlDebugService::isDebuggingEnabled() || !m_enabled)
+    if (!QQmlDebugService::isDebuggingEnabled() || !enabled)
         return;
 
     QQmlProfilerData rd = {m_timer.nsecsElapsed(), (int)RangeData, (int)range,
-                           rData, -1, -1, 0, 0, 0};
+                           rData, -1, -1, 0, 0, 0,
+                           0, 0, 0, 0, 0};
     processMessage(rd);
 }
 
 void QQmlProfilerService::rangeData(RangeType range, const QUrl &rData)
 {
-    if (!QQmlDebugService::isDebuggingEnabled() || !m_enabled)
+    if (!QQmlDebugService::isDebuggingEnabled() || !enabled)
         return;
 
     QQmlProfilerData rd = {m_timer.nsecsElapsed(), (int)RangeData, (int)range,
-                           rData.toString(), -1, -1, 0, 0, 0};
+                           rData.toString(), -1, -1, 0, 0, 0,
+                           0, 0, 0, 0, 0};
     processMessage(rd);
 }
 
 void QQmlProfilerService::rangeLocation(RangeType range, const QString &fileName, int line, int column)
 {
-    if (!QQmlDebugService::isDebuggingEnabled() || !m_enabled)
+    if (!QQmlDebugService::isDebuggingEnabled() || !enabled)
         return;
 
     QQmlProfilerData rd = {m_timer.nsecsElapsed(), (int)RangeLocation, (int)range,
-                           fileName, line, column, 0, 0, 0};
+                           fileName, line, column, 0, 0, 0,
+                           0, 0, 0, 0, 0};
     processMessage(rd);
 }
 
 void QQmlProfilerService::rangeLocation(RangeType range, const QUrl &fileName, int line, int column)
 {
-    if (!QQmlDebugService::isDebuggingEnabled() || !m_enabled)
+    if (!QQmlDebugService::isDebuggingEnabled() || !enabled)
         return;
 
     QQmlProfilerData rd = {m_timer.nsecsElapsed(), (int)RangeLocation, (int)range,
-                           fileName.toString(), line, column, 0, 0, 0};
+                           fileName.toString(), line, column, 0, 0, 0,
+                           0, 0, 0, 0, 0};
     processMessage(rd);
 }
 
 void QQmlProfilerService::endRange(RangeType range)
 {
-    if (!QQmlDebugService::isDebuggingEnabled() || !m_enabled)
+    if (!QQmlDebugService::isDebuggingEnabled() || !enabled)
         return;
 
     QQmlProfilerData rd = {m_timer.nsecsElapsed(), (int)RangeEnd, (int)range,
-                           QString(), -1, -1, 0, 0, 0};
+                           QString(), -1, -1, 0, 0, 0,
+                           0, 0, 0, 0, 0};
+    processMessage(rd);
+}
+
+void QQmlProfilerService::pixmapEventImpl(PixmapEventType eventType, const QUrl &url)
+{
+    // assuming enabled checked by caller
+    QQmlProfilerData rd = {m_timer.nsecsElapsed(), (int)PixmapCacheEvent, (int)eventType,
+                           url.toString(), -1, -1, -1, -1, -1,
+                           0, 0, 0, 0, 0};
+    processMessage(rd);
+}
+
+void QQmlProfilerService::pixmapEventImpl(PixmapEventType eventType, const QUrl &url, int width, int height)
+{
+    // assuming enabled checked by caller
+    QQmlProfilerData rd = {m_timer.nsecsElapsed(), (int)PixmapCacheEvent, (int)eventType,
+                           url.toString(), width, height, -1, -1, -1,
+                           0, 0, 0, 0, 0};
+    processMessage(rd);
+}
+
+void QQmlProfilerService::pixmapEventImpl(PixmapEventType eventType, const QUrl &url, int count)
+{
+    // assuming enabled checked by caller
+    QQmlProfilerData rd = {m_timer.nsecsElapsed(), (int)PixmapCacheEvent, (int)eventType,
+                           url.toString(), -1, -1, -1, count, -1,
+                           0, 0, 0, 0, 0};
+    processMessage(rd);
+}
+
+void QQmlProfilerService::sceneGraphFrameImpl(SceneGraphFrameType frameType, qint64 value1, qint64 value2, qint64 value3, qint64 value4, qint64 value5)
+{
+    if (!QQmlDebugService::isDebuggingEnabled() || !enabled)
+        return;
+
+    // because I already have some space to store ints in the struct, I'll use it to store the frame data
+    // even though the field names do not match
+    QQmlProfilerData rd = {m_timer.nsecsElapsed(), (int)SceneGraphFrame, (int)frameType, QString(),
+                           -1, -1, -1, -1, -1,
+                           value1, value2, value3, value4, value5};
     processMessage(rd);
 }
 
 void QQmlProfilerService::animationFrameImpl(qint64 delta)
 {
     Q_ASSERT(QQmlDebugService::isDebuggingEnabled());
-    if (!m_enabled)
+    if (!enabled)
         return;
 
     int animCount = QUnifiedTimer::instance()->runningAnimationCount();
@@ -250,7 +337,8 @@ void QQmlProfilerService::animationFrameImpl(qint64 delta)
         // trim fps to integer
         int fps = 1000 / delta;
         QQmlProfilerData ed = {m_timer.nsecsElapsed(), (int)Event, (int)AnimationFrame,
-                               QString(), -1, -1, fps, animCount, 0};
+                               QString(), -1, -1, fps, animCount, 0,
+                               0, 0, 0, 0, 0};
         processMessage(ed);
     }
 }
@@ -267,12 +355,12 @@ void QQmlProfilerService::processMessage(const QQmlProfilerData &message)
 
 bool QQmlProfilerService::profilingEnabled()
 {
-    return m_enabled;
+    return enabled;
 }
 
 void QQmlProfilerService::setProfilingEnabled(bool enable)
 {
-    m_enabled = enable;
+    enabled = enable;
 }
 
 /*
@@ -281,6 +369,7 @@ void QQmlProfilerService::setProfilingEnabled(bool enable)
 void QQmlProfilerService::sendMessages()
 {
     QMutexLocker locker(&m_dataMutex);
+
     QList<QByteArray> messages;
     for (int i = 0; i < m_data.count(); ++i)
         messages << m_data.at(i).toByteArray();
@@ -303,7 +392,7 @@ void QQmlProfilerService::stateAboutToBeChanged(QQmlDebugService::State newState
         return;
 
     if (state() == Enabled
-            && m_enabled) {
+            && enabled) {
         stopProfilingImpl();
         sendMessages();
     }
diff --git a/src/qml/debugger/qqmlprofilerservice_p.h b/src/qml/debugger/qqmlprofilerservice_p.h
index a50fb5ea08..fb08a30c6a 100644
--- a/src/qml/debugger/qqmlprofilerservice_p.h
+++ b/src/qml/debugger/qqmlprofilerservice_p.h
@@ -74,12 +74,18 @@ struct Q_AUTOTEST_EXPORT QQmlProfilerData
 
     //###
     QString detailData; //used by RangeData and RangeLocation
-    int line;           //used by RangeLocation
-    int column;         //used by RangeLocation
+    int line;           //used by RangeLocation, also as "width" for pixmaps
+    int column;         //used by RangeLocation, also as "height" for pixmaps
     int framerate;      //used by animation events
-    int animationcount; //used by animation events
+    int animationcount; //used by animation events, also as "cache/reference count" for pixmaps
     int bindingType;
 
+    qint64 subtime_1;
+    qint64 subtime_2;
+    qint64 subtime_3;
+    qint64 subtime_4;
+    qint64 subtime_5;
+
     QByteArray toByteArray() const;
 };
 
@@ -99,6 +105,8 @@ public:
         RangeLocation,
         RangeEnd,
         Complete, // end of transmission
+        PixmapCacheEvent,
+        SceneGraphFrame,
 
         MaximumMessage
     };
@@ -132,14 +140,43 @@ public:
         MaximumBindingType
     };
 
+    enum PixmapEventType {
+        PixmapSizeKnown,
+        PixmapReferenceCountChanged,
+        PixmapCacheCountChanged,
+        PixmapLoadingStarted,
+        PixmapLoadingFinished,
+        PixmapLoadingError,
+
+        MaximumPixmapEventType
+    };
+
+    enum SceneGraphFrameType {
+        SceneGraphRendererFrame,
+        SceneGraphAdaptationLayerFrame,
+        SceneGraphContextFrame,
+        SceneGraphRenderLoopFrame,
+        SceneGraphTexturePrepare,
+        SceneGraphTextureDeletion,
+        SceneGraphPolishAndSync,
+        SceneGraphWindowsRenderShow,
+        SceneGraphWindowsAnimations,
+        SceneGraphWindowsPolishFrame,
+
+        MaximumSceneGraphFrameType
+    };
+
     static void initialize();
 
     static bool startProfiling();
     static bool stopProfiling();
     static void sendStartedProfilingMessage();
+    static bool profilingEnabled();
+
     static void addEvent(EventType);
     static void animationFrame(qint64);
 
+    static void sceneGraphFrame(SceneGraphFrameType frameType, qint64 value1, qint64 value2 = -1, qint64 value3 = -1, qint64 value4 = -1, qint64 value5 = -1);
     static void sendProfilingData();
 
     QQmlProfilerService();
@@ -163,15 +200,22 @@ private:
     void rangeLocation(RangeType, const QUrl &, int, int);
     void endRange(RangeType);
 
+    // overloading depending on parameters
+    void pixmapEventImpl(PixmapEventType eventType, const QUrl &url);
+    void pixmapEventImpl(PixmapEventType eventType, const QUrl &url, int width, int height);
+    void pixmapEventImpl(PixmapEventType eventType, const QUrl &url, int count);
+
+    void sceneGraphFrameImpl(SceneGraphFrameType frameType, qint64 value1, qint64 value2, qint64 value3, qint64 value4, qint64 value5);
+
 
-    bool profilingEnabled();
     void setProfilingEnabled(bool enable);
     void sendMessages();
     void processMessage(const QQmlProfilerData &);
 
+public:
+    static bool enabled;
 private:
     QElapsedTimer m_timer;
-    bool m_enabled;
     QVector<QQmlProfilerData> m_data;
     QMutex m_dataMutex;
     QMutex m_initializeMutex;
@@ -183,6 +227,7 @@ private:
     friend struct QQmlHandlingSignalProfiler;
     friend struct QQmlObjectCreatingProfiler;
     friend struct QQmlCompilingProfiler;
+    friend struct QQmlPixmapProfiler;
 };
 
 //
@@ -288,6 +333,49 @@ struct QQmlCompilingProfiler {
     bool enabled;
 };
 
+struct QQmlPixmapProfiler {
+    QQmlPixmapProfiler() {
+        QQmlProfilerService *instance = QQmlProfilerService::instance;
+        enabled = instance ?
+                    instance->profilingEnabled() : false;
+    }
+
+    ~QQmlPixmapProfiler() {}
+
+    void startLoading(const QUrl &pixmapUrl) {
+        if (enabled) {
+            QQmlProfilerService::instance->pixmapEventImpl(QQmlProfilerService::PixmapLoadingStarted, pixmapUrl);
+        }
+    }
+    void finishLoading(const QUrl &pixmapUrl) {
+        if (enabled) {
+            QQmlProfilerService::instance->pixmapEventImpl(QQmlProfilerService::PixmapLoadingFinished, pixmapUrl);
+        }
+    }
+    void errorLoading(const QUrl &pixmapUrl) {
+        if (enabled) {
+            QQmlProfilerService::instance->pixmapEventImpl(QQmlProfilerService::PixmapLoadingError, pixmapUrl);
+        }
+    }
+    void cacheCountChanged(const QUrl &pixmapUrl, int cacheCount) {
+        if (enabled) {
+            QQmlProfilerService::instance->pixmapEventImpl(QQmlProfilerService::PixmapCacheCountChanged, pixmapUrl, cacheCount);
+        }
+    }
+    void referenceCountChanged(const QUrl &pixmapUrl, int referenceCount) {
+        if (enabled) {
+            QQmlProfilerService::instance->pixmapEventImpl(QQmlProfilerService::PixmapReferenceCountChanged, pixmapUrl, referenceCount);
+        }
+    }
+    void setSize(const QUrl &pixmapUrl, int width, int height) {
+        if (enabled) {
+            QQmlProfilerService::instance->pixmapEventImpl(QQmlProfilerService::PixmapSizeKnown, pixmapUrl, width, height);
+        }
+    }
+
+    bool enabled;
+};
+
 QT_END_NAMESPACE
 
 #endif // QQMLPROFILERSERVICE_P_H
diff --git a/src/qml/debugger/qv8debugservice.cpp b/src/qml/debugger/qv8debugservice.cpp
index f0f7f7a28d..eeab21d6ab 100644
--- a/src/qml/debugger/qv8debugservice.cpp
+++ b/src/qml/debugger/qv8debugservice.cpp
@@ -186,9 +186,14 @@ void QV8DebugService::signalEmitted(const QString &signal)
 // executed in the gui thread
 void QV8DebugService::init()
 {
-//    ### FIXME: v4
-//    v8::Debug::SetMessageHandler2(DebugMessageHandler);
-//    v8::Debug::SetDebugMessageDispatchHandler(DebugMessageDispatchHandler);
+#if 0 // ### FIXME: v4
+    Q_D(QV8DebugService);
+    if (!d->debugIsolate)
+        d->debugIsolate = v8::Isolate::GetCurrent();
+    v8::Debug::SetMessageHandler2(DebugMessageHandler);
+    v8::Debug::SetDebugMessageDispatchHandler(DebugMessageDispatchHandler);
+    QV4Compiler::enableV4(false);
+#endif
 }
 
 // executed in the gui thread
@@ -268,7 +273,10 @@ void QV8DebugService::messageReceived(const QByteArray &message)
 
 void QV8DebugService::sendDebugMessage(const QString &message)
 {
-//  ### FIXME: v4  v8::Debug::SendCommand(message.utf16(), message.size());
+#if 0 // ### FIXME: v4
+    Q_D(QV8DebugService);
+    v8::Debug::SendCommand(message.utf16(), message.size(), 0, d->debugIsolate);
+#endif
 }
 
 void QV8DebugService::processDebugMessages()
diff --git a/src/qml/debugger/qv8debugservice_p.h b/src/qml/debugger/qv8debugservice_p.h
index 00ecf557c3..e6f05a2397 100644
--- a/src/qml/debugger/qv8debugservice_p.h
+++ b/src/qml/debugger/qv8debugservice_p.h
@@ -54,6 +54,11 @@
 //
 
 #include "qqmldebugservice_p.h"
+#ifdef Q_OS_WINCE
+#  ifdef DebugBreak
+#    undef DebugBreak
+#  endif
+#endif
 #include <private/qv8debug_p.h>
 
 QT_BEGIN_NAMESPACE