QmlDebug: Split QV4::Debugging::Debugger

... into a pure interface and a QV4::Debugging::V4Debugger implementation.

This is in preparation of a second implementation of this interface
to be used with 'native mixed' debugging.

Change-Id: I3078dcfe4bdee392a2d13ef43a55ca993e7b88d8
Reviewed-by: Ulf Hermann <ulf.hermann@theqtcompany.com>

11 files changed, 156 insertions, 136 deletions

diff --git a/src/plugins/qmltooling/qmldbg_debugger/qv4datacollector.cpp b/src/plugins/qmltooling/qmldbg_debugger/qv4datacollector.cpp
index db8c1feb92..4cca1900de 100644
--- a/src/plugins/qmltooling/qmldbg_debugger/qv4datacollector.cpp
+++ b/src/plugins/qmltooling/qmldbg_debugger/qv4datacollector.cpp
@@ -208,13 +208,13 @@ QV4DataCollector::Ref QV4DataCollector::addScriptRef(const QString &scriptName)
     return ref;
 }
 
-void QV4DataCollector::collectScope(QJsonObject *dict, QV4::Debugging::Debugger *debugger,
+void QV4DataCollector::collectScope(QJsonObject *dict, QV4::Debugging::V4Debugger *debugger,
                                     int frameNr, int scopeNr)
 {
     QStringList names;
 
     Refs refs;
-    if (debugger->state() == QV4::Debugging::Debugger::Paused) {
+    if (debugger->state() == QV4::Debugging::V4Debugger::Paused) {
         RefHolder holder(this, &refs);
         ArgumentCollectJob argumentsJob(m_engine, this, &names, frameNr, scopeNr);
         debugger->runInEngine(&argumentsJob);
@@ -359,7 +359,8 @@ void GatherSourcesJob::run()
             sources.append(fileName);
     }
 
-    QV4::Debugging::Debugger *debugger = engine->debugger;
+    QV4::Debugging::V4Debugger *debugger
+            = static_cast<QV4::Debugging::V4Debugger *>(engine->debugger);
     emit debugger->sourcesCollected(debugger, sources, seq);
 }
 
diff --git a/src/plugins/qmltooling/qmldbg_debugger/qv4datacollector.h b/src/plugins/qmltooling/qmldbg_debugger/qv4datacollector.h
index fb78c1614a..d0e4a4ad18 100644
--- a/src/plugins/qmltooling/qmldbg_debugger/qv4datacollector.h
+++ b/src/plugins/qmltooling/qmldbg_debugger/qv4datacollector.h
@@ -60,7 +60,7 @@ public:
     Ref addFunctionRef(const QString &functionName);
     Ref addScriptRef(const QString &scriptName);
 
-    void collectScope(QJsonObject *dict, QV4::Debugging::Debugger *debugger, int frameNr,
+    void collectScope(QJsonObject *dict, QV4::Debugging::V4Debugger *debugger, int frameNr,
                       int scopeNr);
 
     QV4::ExecutionEngine *engine() const { return m_engine; }
@@ -101,7 +101,7 @@ private:
     QV4DataCollector::Refs *m_previousRefs;
 };
 
-class ExpressionEvalJob: public QV4::Debugging::Debugger::JavaScriptJob
+class ExpressionEvalJob: public QV4::Debugging::V4Debugger::JavaScriptJob
 {
     QV4DataCollector *collector;
     QString exception;
@@ -113,7 +113,7 @@ public:
     const QString &exceptionMessage() const;
 };
 
-class GatherSourcesJob: public QV4::Debugging::Debugger::Job
+class GatherSourcesJob: public QV4::Debugging::V4Debugger::Job
 {
     QV4::ExecutionEngine *engine;
     const int seq;
@@ -123,7 +123,7 @@ public:
     void run();
 };
 
-class ArgumentCollectJob: public QV4::Debugging::Debugger::Job
+class ArgumentCollectJob: public QV4::Debugging::V4Debugger::Job
 {
     QV4::ExecutionEngine *engine;
     QV4DataCollector *collector;
@@ -137,7 +137,7 @@ public:
     void run();
 };
 
-class LocalCollectJob: public QV4::Debugging::Debugger::Job
+class LocalCollectJob: public QV4::Debugging::V4Debugger::Job
 {
     QV4::ExecutionEngine *engine;
     QV4DataCollector *collector;
@@ -151,7 +151,7 @@ public:
     void run();
 };
 
-class ThisCollectJob: public QV4::Debugging::Debugger::Job
+class ThisCollectJob: public QV4::Debugging::V4Debugger::Job
 {
     QV4::ExecutionEngine *engine;
     QV4DataCollector *collector;
@@ -165,7 +165,7 @@ public:
     bool myRun();
 };
 
-class ExceptionCollectJob: public QV4::Debugging::Debugger::Job
+class ExceptionCollectJob: public QV4::Debugging::V4Debugger::Job
 {
     QV4::ExecutionEngine *engine;
     QV4DataCollector *collector;
diff --git a/src/plugins/qmltooling/qmldbg_debugger/qv4debuggeragent.cpp b/src/plugins/qmltooling/qmldbg_debugger/qv4debuggeragent.cpp
index 7f22b16e45..e33595c629 100644
--- a/src/plugins/qmltooling/qmldbg_debugger/qv4debuggeragent.cpp
+++ b/src/plugins/qmltooling/qmldbg_debugger/qv4debuggeragent.cpp
@@ -44,7 +44,7 @@ QV4DebuggerAgent::QV4DebuggerAgent(QV4DebugServiceImpl *debugService)
     : m_breakOnThrow(false), m_debugService(debugService)
 {}
 
-QV4::Debugging::Debugger *QV4DebuggerAgent::firstDebugger() const
+QV4::Debugging::V4Debugger *QV4DebuggerAgent::firstDebugger() const
 {
     // Currently only 1 single engine is supported, so:
     if (m_debuggers.isEmpty())
@@ -56,13 +56,13 @@ QV4::Debugging::Debugger *QV4DebuggerAgent::firstDebugger() const
 bool QV4DebuggerAgent::isRunning() const
 {
     // Currently only 1 single engine is supported, so:
-    if (QV4::Debugging::Debugger *debugger = firstDebugger())
-        return debugger->state() == QV4::Debugging::Debugger::Running;
+    if (QV4::Debugging::V4Debugger *debugger = firstDebugger())
+        return debugger->state() == QV4::Debugging::V4Debugger::Running;
     else
         return false;
 }
 
-void QV4DebuggerAgent::debuggerPaused(QV4::Debugging::Debugger *debugger,
+void QV4DebuggerAgent::debuggerPaused(QV4::Debugging::V4Debugger *debugger,
                                       QV4::Debugging::PauseReason reason)
 {
     Q_UNUSED(reason);
@@ -105,7 +105,7 @@ void QV4DebuggerAgent::debuggerPaused(QV4::Debugging::Debugger *debugger,
     m_debugService->send(event);
 }
 
-void QV4DebuggerAgent::sourcesCollected(QV4::Debugging::Debugger *debugger,
+void QV4DebuggerAgent::sourcesCollected(QV4::Debugging::V4Debugger *debugger,
                                         const QStringList &sources, int requestSequenceNr)
 {
     QJsonArray body;
@@ -118,7 +118,7 @@ void QV4DebuggerAgent::sourcesCollected(QV4::Debugging::Debugger *debugger,
 
     QJsonObject response;
     response[QLatin1String("success")] = true;
-    response[QLatin1String("running")] = debugger->state() == QV4::Debugging::Debugger::Running;
+    response[QLatin1String("running")] = debugger->state() == QV4::Debugging::V4Debugger::Running;
     response[QLatin1String("body")] = body;
     response[QLatin1String("command")] = QStringLiteral("scripts");
     response[QLatin1String("request_seq")] = requestSequenceNr;
@@ -126,7 +126,7 @@ void QV4DebuggerAgent::sourcesCollected(QV4::Debugging::Debugger *debugger,
     m_debugService->send(response);
 }
 
-void QV4DebuggerAgent::addDebugger(QV4::Debugging::Debugger *debugger)
+void QV4DebuggerAgent::addDebugger(QV4::Debugging::V4Debugger *debugger)
 {
     Q_ASSERT(!m_debuggers.contains(debugger));
     m_debuggers << debugger;
@@ -139,54 +139,55 @@ void QV4DebuggerAgent::addDebugger(QV4::Debugging::Debugger *debugger)
 
     connect(debugger, SIGNAL(destroyed(QObject*)),
             this, SLOT(handleDebuggerDeleted(QObject*)));
-    connect(debugger, SIGNAL(sourcesCollected(QV4::Debugging::Debugger*,QStringList,int)),
-            this, SLOT(sourcesCollected(QV4::Debugging::Debugger*,QStringList,int)),
+    connect(debugger, SIGNAL(sourcesCollected(QV4::Debugging::V4Debugger*,QStringList,int)),
+            this, SLOT(sourcesCollected(QV4::Debugging::V4Debugger*,QStringList,int)),
             Qt::QueuedConnection);
-    connect(debugger, SIGNAL(debuggerPaused(QV4::Debugging::Debugger*,QV4::Debugging::PauseReason)),
-            this, SLOT(debuggerPaused(QV4::Debugging::Debugger*,QV4::Debugging::PauseReason)),
+    connect(debugger,
+            SIGNAL(debuggerPaused(QV4::Debugging::V4Debugger*,QV4::Debugging::PauseReason)),
+            this, SLOT(debuggerPaused(QV4::Debugging::V4Debugger*,QV4::Debugging::PauseReason)),
             Qt::QueuedConnection);
 }
 
-void QV4DebuggerAgent::removeDebugger(QV4::Debugging::Debugger *debugger)
+void QV4DebuggerAgent::removeDebugger(QV4::Debugging::V4Debugger *debugger)
 {
     m_debuggers.removeAll(debugger);
     disconnect(debugger, SIGNAL(destroyed(QObject*)),
                this, SLOT(handleDebuggerDeleted(QObject*)));
-    disconnect(debugger, SIGNAL(sourcesCollected(QV4::Debugging::Debugger*,QStringList,int)),
-               this, SLOT(sourcesCollected(QV4::Debugging::Debugger*,QStringList,int)));
+    disconnect(debugger, SIGNAL(sourcesCollected(QV4::Debugging::V4Debugger*,QStringList,int)),
+               this, SLOT(sourcesCollected(QV4::Debugging::V4Debugger*,QStringList,int)));
     disconnect(debugger,
-               SIGNAL(debuggerPaused(QV4::Debugging::Debugger*,QV4::Debugging::PauseReason)),
+               SIGNAL(debuggerPaused(QV4::Debugging::V4Debugger*,QV4::Debugging::PauseReason)),
                this,
-               SLOT(debuggerPaused(QV4::Debugging::Debugger*,QV4::Debugging::PauseReason)));
+               SLOT(debuggerPaused(QV4::Debugging::V4Debugger*,QV4::Debugging::PauseReason)));
 }
 
 void QV4DebuggerAgent::handleDebuggerDeleted(QObject *debugger)
 {
-    m_debuggers.removeAll(static_cast<QV4::Debugging::Debugger *>(debugger));
+    m_debuggers.removeAll(static_cast<QV4::Debugging::V4Debugger *>(debugger));
 }
 
-void QV4DebuggerAgent::pause(QV4::Debugging::Debugger *debugger) const
+void QV4DebuggerAgent::pause(QV4::Debugging::V4Debugger *debugger) const
 {
     debugger->pause();
 }
 
 void QV4DebuggerAgent::pauseAll() const
 {
-    foreach (QV4::Debugging::Debugger *debugger, m_debuggers)
+    foreach (QV4::Debugging::V4Debugger *debugger, m_debuggers)
         pause(debugger);
 }
 
 void QV4DebuggerAgent::resumeAll() const
 {
-    foreach (QV4::Debugging::Debugger *debugger, m_debuggers)
-        if (debugger->state() == QV4::Debugging::Debugger::Paused)
-            debugger->resume(QV4::Debugging::Debugger::FullThrottle);
+    foreach (QV4::Debugging::V4Debugger *debugger, m_debuggers)
+        if (debugger->state() == QV4::Debugging::V4Debugger::Paused)
+            debugger->resume(QV4::Debugging::V4Debugger::FullThrottle);
 }
 
 int QV4DebuggerAgent::addBreakPoint(const QString &fileName, int lineNumber, bool enabled, const QString &condition)
 {
     if (enabled)
-        foreach (QV4::Debugging::Debugger *debugger, m_debuggers)
+        foreach (QV4::Debugging::V4Debugger *debugger, m_debuggers)
             debugger->addBreakPoint(fileName, lineNumber, condition);
 
     int id = m_breakPoints.size();
@@ -203,7 +204,7 @@ void QV4DebuggerAgent::removeBreakPoint(int id)
     m_breakPoints.remove(id);
 
     if (breakPoint.enabled)
-        foreach (QV4::Debugging::Debugger *debugger, m_debuggers)
+        foreach (QV4::Debugging::V4Debugger *debugger, m_debuggers)
             debugger->removeBreakPoint(breakPoint.fileName, breakPoint.lineNr);
 }
 
@@ -221,7 +222,7 @@ void QV4DebuggerAgent::enableBreakPoint(int id, bool onoff)
         return;
     breakPoint.enabled = onoff;
 
-    foreach (QV4::Debugging::Debugger *debugger, m_debuggers) {
+    foreach (QV4::Debugging::V4Debugger *debugger, m_debuggers) {
         if (onoff)
             debugger->addBreakPoint(breakPoint.fileName, breakPoint.lineNr, breakPoint.condition);
         else
@@ -244,7 +245,7 @@ void QV4DebuggerAgent::setBreakOnThrow(bool onoff)
 {
     if (onoff != m_breakOnThrow) {
         m_breakOnThrow = onoff;
-        foreach (QV4::Debugging::Debugger *debugger, m_debuggers)
+        foreach (QV4::Debugging::V4Debugger *debugger, m_debuggers)
             debugger->setBreakOnThrow(onoff);
     }
 }
diff --git a/src/plugins/qmltooling/qmldbg_debugger/qv4debuggeragent.h b/src/plugins/qmltooling/qmldbg_debugger/qv4debuggeragent.h
index 6126eea772..eafb408e7a 100644
--- a/src/plugins/qmltooling/qmldbg_debugger/qv4debuggeragent.h
+++ b/src/plugins/qmltooling/qmldbg_debugger/qv4debuggeragent.h
@@ -46,13 +46,13 @@ class QV4DebuggerAgent : public QObject
 public:
     QV4DebuggerAgent(QV4DebugServiceImpl *m_debugService);
 
-    QV4::Debugging::Debugger *firstDebugger() const;
+    QV4::Debugging::V4Debugger *firstDebugger() const;
     bool isRunning() const;
 
-    void addDebugger(QV4::Debugging::Debugger *debugger);
-    void removeDebugger(QV4::Debugging::Debugger *debugger);
+    void addDebugger(QV4::Debugging::V4Debugger *debugger);
+    void removeDebugger(QV4::Debugging::V4Debugger *debugger);
 
-    void pause(QV4::Debugging::Debugger *debugger) const;
+    void pause(QV4::Debugging::V4Debugger *debugger) const;
     void pauseAll() const;
     void resumeAll() const;
     int addBreakPoint(const QString &fileName, int lineNumber, bool enabled = true, const QString &condition = QString());
@@ -65,13 +65,13 @@ public:
     void setBreakOnThrow(bool onoff);
 
 public slots:
-    void debuggerPaused(QV4::Debugging::Debugger *debugger, QV4::Debugging::PauseReason reason);
-    void sourcesCollected(QV4::Debugging::Debugger *debugger, const QStringList &sources,
+    void debuggerPaused(QV4::Debugging::V4Debugger *debugger, QV4::Debugging::PauseReason reason);
+    void sourcesCollected(QV4::Debugging::V4Debugger *debugger, const QStringList &sources,
                           int requestSequenceNr);
     void handleDebuggerDeleted(QObject *debugger);
 
 private:
-    QList<QV4::Debugging::Debugger *> m_debuggers;
+    QList<QV4::Debugging::V4Debugger *> m_debuggers;
 
     struct BreakPoint {
         QString fileName;
diff --git a/src/plugins/qmltooling/qmldbg_debugger/qv4debugservice.cpp b/src/plugins/qmltooling/qmldbg_debugger/qv4debugservice.cpp
index 0fb6df7fd2..306c3c4d1a 100644
--- a/src/plugins/qmltooling/qmldbg_debugger/qv4debugservice.cpp
+++ b/src/plugins/qmltooling/qmldbg_debugger/qv4debugservice.cpp
@@ -270,7 +270,7 @@ public:
         int toFrame = arguments.value(QStringLiteral("toFrame")).toInt(fromFrame + 10);
         // no idea what the bottom property is for, so we'll ignore it.
 
-        QV4::Debugging::Debugger *debugger = debugService->debuggerAgent.firstDebugger();
+        QV4::Debugging::V4Debugger *debugger = debugService->debuggerAgent.firstDebugger();
 
         QJsonArray frameArray;
         QVector<QV4::StackFrame> frames = debugger->stackTrace(toFrame);
@@ -307,7 +307,7 @@ public:
         const int frameNr = arguments.value(QStringLiteral("number")).toInt(
                     debugService->selectedFrame());
 
-        QV4::Debugging::Debugger *debugger = debugService->debuggerAgent.firstDebugger();
+        QV4::Debugging::V4Debugger *debugger = debugService->debuggerAgent.firstDebugger();
         QVector<QV4::StackFrame> frames = debugger->stackTrace(frameNr + 1);
         if (frameNr < 0 || frameNr >= frames.size()) {
             createErrorResponse(QStringLiteral("frame command has invalid frame number"));
@@ -340,7 +340,7 @@ public:
                     debugService->selectedFrame());
         const int scopeNr = arguments.value(QStringLiteral("number")).toInt(0);
 
-        QV4::Debugging::Debugger *debugger = debugService->debuggerAgent.firstDebugger();
+        QV4::Debugging::V4Debugger *debugger = debugService->debuggerAgent.firstDebugger();
         QVector<QV4::StackFrame> frames = debugger->stackTrace(frameNr + 1);
         if (frameNr < 0 || frameNr >= frames.size()) {
             createErrorResponse(QStringLiteral("scope command has invalid frame number"));
@@ -398,10 +398,10 @@ public:
         // decypher the payload:
         QJsonObject arguments = req.value(QStringLiteral("arguments")).toObject();
 
-        QV4::Debugging::Debugger *debugger = debugService->debuggerAgent.firstDebugger();
+        QV4::Debugging::V4Debugger *debugger = debugService->debuggerAgent.firstDebugger();
 
         if (arguments.empty()) {
-            debugger->resume(QV4::Debugging::Debugger::FullThrottle);
+            debugger->resume(QV4::Debugging::V4Debugger::FullThrottle);
         } else {
             QJsonObject arguments = req.value(QStringLiteral("arguments")).toObject();
             QString stepAction = arguments.value(QStringLiteral("stepaction")).toString();
@@ -410,11 +410,11 @@ public:
                 qWarning() << "Step count other than 1 is not supported.";
 
             if (stepAction == QStringLiteral("in")) {
-                debugger->resume(QV4::Debugging::Debugger::StepIn);
+                debugger->resume(QV4::Debugging::V4Debugger::StepIn);
             } else if (stepAction == QStringLiteral("out")) {
-                debugger->resume(QV4::Debugging::Debugger::StepOut);
+                debugger->resume(QV4::Debugging::V4Debugger::StepOut);
             } else if (stepAction == QStringLiteral("next")) {
-                debugger->resume(QV4::Debugging::Debugger::StepOver);
+                debugger->resume(QV4::Debugging::V4Debugger::StepOver);
             } else {
                 createErrorResponse(QStringLiteral("continue command has invalid stepaction"));
                 return;
@@ -506,7 +506,7 @@ public:
         }
 
         // do it:
-        QV4::Debugging::Debugger *debugger = debugService->debuggerAgent.firstDebugger();
+        QV4::Debugging::V4Debugger *debugger = debugService->debuggerAgent.firstDebugger();
         GatherSourcesJob job(debugger->engine(), requestSequenceNr());
         debugger->runInEngine(&job);
 
@@ -549,8 +549,8 @@ public:
 
     virtual void handleRequest()
     {
-        QV4::Debugging::Debugger *debugger = debugService->debuggerAgent.firstDebugger();
-        if (debugger->state() == QV4::Debugging::Debugger::Paused) {
+        QV4::Debugging::V4Debugger *debugger = debugService->debuggerAgent.firstDebugger();
+        if (debugger->state() == QV4::Debugging::V4Debugger::Paused) {
             QJsonObject arguments = req.value(QStringLiteral("arguments")).toObject();
             QString expression = arguments.value(QStringLiteral("expression")).toString();
             const int frame = arguments.value(QStringLiteral("frame")).toInt(0);
@@ -621,8 +621,8 @@ void QV4DebugServiceImpl::engineAboutToBeAdded(QQmlEngine *engine)
         QV4::ExecutionEngine *ee = QV8Engine::getV4(engine->handle());
         if (QQmlDebugConnector *server = QQmlDebugConnector::instance()) {
             if (ee) {
-                ee->enableDebugger();
-                QV4::Debugging::Debugger *debugger = ee->debugger;
+                QV4::Debugging::V4Debugger *debugger = new QV4::Debugging::V4Debugger(ee);
+                ee->setDebugger(debugger);
                 debuggerMap.insert(debuggerIndex++, debugger);
                 debuggerAgent.addDebugger(debugger);
                 debuggerAgent.moveToThread(server->thread());
@@ -638,8 +638,9 @@ void QV4DebugServiceImpl::engineAboutToBeRemoved(QQmlEngine *engine)
     if (engine){
         const QV4::ExecutionEngine *ee = QV8Engine::getV4(engine->handle());
         if (ee) {
-            QV4::Debugging::Debugger *debugger = ee->debugger;
-            typedef QMap<int, QV4::Debugging::Debugger *>::const_iterator DebuggerMapIterator;
+            QV4::Debugging::V4Debugger *debugger
+                    = static_cast<QV4::Debugging::V4Debugger *>(ee->debugger);
+            typedef QMap<int, QV4::Debugging::V4Debugger *>::const_iterator DebuggerMapIterator;
             const DebuggerMapIterator end = debuggerMap.constEnd();
             for (DebuggerMapIterator i = debuggerMap.constBegin(); i != end; ++i) {
                 if (i.value() == debugger) {
@@ -769,7 +770,7 @@ void QV4DebugServiceImpl::clearHandles(QV4::ExecutionEngine *engine)
 }
 
 QJsonObject QV4DebugServiceImpl::buildFrame(const QV4::StackFrame &stackFrame, int frameNr,
-                                        QV4::Debugging::Debugger *debugger)
+                                        QV4::Debugging::V4Debugger *debugger)
 {
     QV4DataCollector::Ref ref;
 
@@ -787,7 +788,7 @@ QJsonObject QV4DebugServiceImpl::buildFrame(const QV4::StackFrame &stackFrame, i
         frame[QLatin1String("column")] = stackFrame.column;
 
     QJsonArray scopes;
-    if (debugger->state() == QV4::Debugging::Debugger::Paused) {
+    if (debugger->state() == QV4::Debugging::V4Debugger::Paused) {
         RefHolder holder(theCollector.data(), &collectedRefs);
         bool foundThis = false;
         ThisCollectJob job(debugger->engine(), theCollector.data(), frameNr, &foundThis);
@@ -837,7 +838,7 @@ int QV4DebugServiceImpl::encodeScopeType(QV4::Heap::ExecutionContext::ContextTyp
 }
 
 QJsonObject QV4DebugServiceImpl::buildScope(int frameNr, int scopeNr,
-                                        QV4::Debugging::Debugger *debugger)
+                                        QV4::Debugging::V4Debugger *debugger)
 {
     QJsonObject scope;
 
@@ -845,7 +846,7 @@ QJsonObject QV4DebugServiceImpl::buildScope(int frameNr, int scopeNr,
     RefHolder holder(theCollector.data(), &collectedRefs);
     theCollector->collectScope(&object, debugger, frameNr, scopeNr);
 
-    if (debugger->state() == QV4::Debugging::Debugger::Paused) {
+    if (debugger->state() == QV4::Debugging::V4Debugger::Paused) {
         QVector<QV4::Heap::ExecutionContext::ContextType> scopeTypes =
                 QV4DataCollector::getScopeTypes(debugger->engine(), frameNr);
         scope[QLatin1String("type")] = encodeScopeType(scopeTypes[scopeNr]);
diff --git a/src/plugins/qmltooling/qmldbg_debugger/qv4debugservice.h b/src/plugins/qmltooling/qmldbg_debugger/qv4debugservice.h
index 6c2950de8c..c4920404a2 100644
--- a/src/plugins/qmltooling/qmldbg_debugger/qv4debugservice.h
+++ b/src/plugins/qmltooling/qmldbg_debugger/qv4debugservice.h
@@ -76,13 +76,13 @@ public:
     void signalEmitted(const QString &signal);
     void send(QJsonObject v8Payload);
 
-    QJsonObject buildScope(int frameNr, int scopeNr, QV4::Debugging::Debugger *debugger);
+    QJsonObject buildScope(int frameNr, int scopeNr, QV4::Debugging::V4Debugger *debugger);
     QJsonArray buildRefs();
     QJsonValue lookup(QV4DataCollector::Ref refId);
     QJsonValue toRef(QV4DataCollector::Ref ref);
 
     QJsonObject buildFrame(const QV4::StackFrame &stackFrame, int frameNr,
-                           QV4::Debugging::Debugger *debugger);
+                           QV4::Debugging::V4Debugger *debugger);
     int selectedFrame() const;
     void selectFrame(int frameNr);
 
@@ -107,7 +107,7 @@ private:
     int encodeScopeType(QV4::Heap::ExecutionContext::ContextType scopeType);
 
     QStringList breakOnSignals;
-    QMap<int, QV4::Debugging::Debugger *> debuggerMap;
+    QMap<int, QV4::Debugging::V4Debugger *> debuggerMap;
     static int debuggerIndex;
     static int sequence;
     const int version;
diff --git a/src/qml/jsruntime/qv4debugging.cpp b/src/qml/jsruntime/qv4debugging.cpp
index 79fd58f700..7706a40da6 100644
--- a/src/qml/jsruntime/qv4debugging.cpp
+++ b/src/qml/jsruntime/qv4debugging.cpp
@@ -54,7 +54,7 @@ QT_BEGIN_NAMESPACE
 using namespace QV4;
 using namespace QV4::Debugging;
 
-Debugger::JavaScriptJob::JavaScriptJob(QV4::ExecutionEngine *engine, int frameNr,
+V4Debugger::JavaScriptJob::JavaScriptJob(QV4::ExecutionEngine *engine, int frameNr,
                                        const QString &script)
     : engine(engine)
     , frameNr(frameNr)
@@ -62,7 +62,7 @@ Debugger::JavaScriptJob::JavaScriptJob(QV4::ExecutionEngine *engine, int frameNr
     , resultIsException(false)
 {}
 
-void Debugger::JavaScriptJob::run()
+void V4Debugger::JavaScriptJob::run()
 {
     Scope scope(engine);
 
@@ -92,18 +92,18 @@ void Debugger::JavaScriptJob::run()
     handleResult(result);
 }
 
-bool Debugger::JavaScriptJob::hasExeption() const
+bool V4Debugger::JavaScriptJob::hasExeption() const
 {
     return resultIsException;
 }
 
-class EvalJob: public Debugger::JavaScriptJob
+class EvalJob: public V4Debugger::JavaScriptJob
 {
     bool result;
 
 public:
     EvalJob(QV4::ExecutionEngine *engine, const QString &script)
-        : Debugger::JavaScriptJob(engine, /*frameNr*/-1, script)
+        : V4Debugger::JavaScriptJob(engine, /*frameNr*/-1, script)
         , result(false)
     {}
 
@@ -118,7 +118,7 @@ public:
     }
 };
 
-Debugger::Debugger(QV4::ExecutionEngine *engine)
+V4Debugger::V4Debugger(QV4::ExecutionEngine *engine)
     : m_engine(engine)
     , m_state(Running)
     , m_stepping(NotStepping)
@@ -129,11 +129,11 @@ Debugger::Debugger(QV4::ExecutionEngine *engine)
     , m_gatherSources(0)
     , m_runningJob(0)
 {
-    qMetaTypeId<Debugger*>();
+    qMetaTypeId<V4Debugger*>();
     qMetaTypeId<PauseReason>();
 }
 
-void Debugger::pause()
+void V4Debugger::pause()
 {
     QMutexLocker locker(&m_lock);
     if (m_state == Paused)
@@ -141,7 +141,7 @@ void Debugger::pause()
     m_pauseRequested = true;
 }
 
-void Debugger::resume(Speed speed)
+void V4Debugger::resume(Speed speed)
 {
     QMutexLocker locker(&m_lock);
     if (m_state != Paused)
@@ -155,28 +155,28 @@ void Debugger::resume(Speed speed)
     m_runningCondition.wakeAll();
 }
 
-void Debugger::addBreakPoint(const QString &fileName, int lineNumber, const QString &condition)
+void V4Debugger::addBreakPoint(const QString &fileName, int lineNumber, const QString &condition)
 {
     QMutexLocker locker(&m_lock);
     m_breakPoints.insert(DebuggerBreakPoint(fileName.mid(fileName.lastIndexOf('/') + 1), lineNumber), condition);
     m_haveBreakPoints = true;
 }
 
-void Debugger::removeBreakPoint(const QString &fileName, int lineNumber)
+void V4Debugger::removeBreakPoint(const QString &fileName, int lineNumber)
 {
     QMutexLocker locker(&m_lock);
     m_breakPoints.remove(DebuggerBreakPoint(fileName.mid(fileName.lastIndexOf('/') + 1), lineNumber));
     m_haveBreakPoints = !m_breakPoints.isEmpty();
 }
 
-void Debugger::setBreakOnThrow(bool onoff)
+void V4Debugger::setBreakOnThrow(bool onoff)
 {
     QMutexLocker locker(&m_lock);
 
     m_breakOnThrow = onoff;
 }
 
-Debugger::ExecutionState Debugger::currentExecutionState() const
+V4Debugger::ExecutionState V4Debugger::currentExecutionState() const
 {
     ExecutionState state;
     state.fileName = getFunction()->sourceFile();
@@ -185,12 +185,12 @@ Debugger::ExecutionState Debugger::currentExecutionState() const
     return state;
 }
 
-QVector<StackFrame> Debugger::stackTrace(int frameLimit) const
+QVector<StackFrame> V4Debugger::stackTrace(int frameLimit) const
 {
     return m_engine->stackTrace(frameLimit);
 }
 
-void Debugger::maybeBreakAtInstruction()
+void V4Debugger::maybeBreakAtInstruction()
 {
     if (m_runningJob) // do not re-enter when we're doing a job for the debugger.
         return;
@@ -228,7 +228,7 @@ void Debugger::maybeBreakAtInstruction()
     }
 }
 
-void Debugger::enteringFunction()
+void V4Debugger::enteringFunction()
 {
     if (m_runningJob)
         return;
@@ -239,7 +239,7 @@ void Debugger::enteringFunction()
     }
 }
 
-void Debugger::leavingFunction(const ReturnedValue &retVal)
+void V4Debugger::leavingFunction(const ReturnedValue &retVal)
 {
     if (m_runningJob)
         return;
@@ -254,7 +254,7 @@ void Debugger::leavingFunction(const ReturnedValue &retVal)
     }
 }
 
-void Debugger::aboutToThrow()
+void V4Debugger::aboutToThrow()
 {
     if (!m_breakOnThrow)
         return;
@@ -266,7 +266,7 @@ void Debugger::aboutToThrow()
     pauseAndWait(Throwing);
 }
 
-Function *Debugger::getFunction() const
+Function *V4Debugger::getFunction() const
 {
     Scope scope(m_engine);
     ExecutionContext *context = m_engine->currentContext;
@@ -277,7 +277,7 @@ Function *Debugger::getFunction() const
         return context->d()->engine->globalCode;
 }
 
-void Debugger::pauseAndWait(PauseReason reason)
+void V4Debugger::pauseAndWait(PauseReason reason)
 {
     if (m_runningJob)
         return;
@@ -298,7 +298,7 @@ void Debugger::pauseAndWait(PauseReason reason)
     m_state = Running;
 }
 
-bool Debugger::reallyHitTheBreakPoint(const QString &filename, int linenr)
+bool V4Debugger::reallyHitTheBreakPoint(const QString &filename, int linenr)
 {
     BreakPoints::iterator it = m_breakPoints.find(DebuggerBreakPoint(filename.mid(filename.lastIndexOf('/') + 1), linenr));
     if (it == m_breakPoints.end())
@@ -316,13 +316,13 @@ bool Debugger::reallyHitTheBreakPoint(const QString &filename, int linenr)
     return evilJob.resultAsBoolean();
 }
 
-void Debugger::runInEngine(Debugger::Job *job)
+void V4Debugger::runInEngine(V4Debugger::Job *job)
 {
     QMutexLocker locker(&m_lock);
     runInEngine_havingLock(job);
 }
 
-void Debugger::runInEngine_havingLock(Debugger::Job *job)
+void V4Debugger::runInEngine_havingLock(V4Debugger::Job *job)
 {
     Q_ASSERT(job);
     Q_ASSERT(m_runningJob == 0);
@@ -333,7 +333,7 @@ void Debugger::runInEngine_havingLock(Debugger::Job *job)
     m_runningJob = 0;
 }
 
-Debugger::Job::~Job()
+V4Debugger::Job::~Job()
 {
 }
 
diff --git a/src/qml/jsruntime/qv4debugging_p.h b/src/qml/jsruntime/qv4debugging_p.h
index 9b07a31f26..fdc9cac24f 100644
--- a/src/qml/jsruntime/qv4debugging_p.h
+++ b/src/qml/jsruntime/qv4debugging_p.h
@@ -93,6 +93,19 @@ typedef QHash<DebuggerBreakPoint, QString> BreakPoints;
 class Q_QML_EXPORT Debugger : public QObject
 {
     Q_OBJECT
+
+public:
+    virtual ~Debugger() {}
+    virtual bool pauseAtNextOpportunity() const = 0;
+    virtual void maybeBreakAtInstruction() = 0;
+    virtual void enteringFunction() = 0;
+    virtual void leavingFunction(const ReturnedValue &retVal) = 0;
+    virtual void aboutToThrow() = 0;
+};
+
+class Q_QML_EXPORT V4Debugger : public Debugger
+{
+    Q_OBJECT
 public:
     class Q_QML_EXPORT Job
     {
@@ -131,7 +144,7 @@ public:
         NotStepping = FullThrottle
     };
 
-    Debugger(ExecutionEngine *engine);
+    V4Debugger(ExecutionEngine *engine);
 
     ExecutionEngine *engine() const
     { return m_engine; }
@@ -173,14 +186,14 @@ public: // execution hooks
     void aboutToThrow();
 
 signals:
-    void sourcesCollected(QV4::Debugging::Debugger *self, const QStringList &sources, int seq);
-    void debuggerPaused(QV4::Debugging::Debugger *self, QV4::Debugging::PauseReason reason);
+    void sourcesCollected(QV4::Debugging::V4Debugger *self, const QStringList &sources, int seq);
+    void debuggerPaused(QV4::Debugging::V4Debugger *self, QV4::Debugging::PauseReason reason);
 
 private:
     // requires lock to be held
     void pauseAndWait(PauseReason reason);
     bool reallyHitTheBreakPoint(const QString &filename, int linenr);
-    void runInEngine_havingLock(Debugger::Job *job);
+    void runInEngine_havingLock(V4Debugger::Job *job);
 
 private:
     QV4::ExecutionEngine *m_engine;
diff --git a/src/qml/jsruntime/qv4engine.cpp b/src/qml/jsruntime/qv4engine.cpp
index 6fe14da850..2732f360b3 100644
--- a/src/qml/jsruntime/qv4engine.cpp
+++ b/src/qml/jsruntime/qv4engine.cpp
@@ -518,10 +518,10 @@ ExecutionEngine::~ExecutionEngine()
     delete [] argumentsAccessors;
 }
 
-void ExecutionEngine::enableDebugger()
+void ExecutionEngine::setDebugger(Debugging::Debugger *debugger_)
 {
     Q_ASSERT(!debugger);
-    debugger = new Debugging::Debugger(this);
+    debugger = debugger_;
     iselFactory.reset(new Moth::ISelFactory);
 }
 
diff --git a/src/qml/jsruntime/qv4engine_p.h b/src/qml/jsruntime/qv4engine_p.h
index e94b417908..4640f3f4cc 100644
--- a/src/qml/jsruntime/qv4engine_p.h
+++ b/src/qml/jsruntime/qv4engine_p.h
@@ -366,7 +366,7 @@ public:
     ExecutionEngine(EvalISelFactory *iselFactory = 0);
     ~ExecutionEngine();
 
-    void enableDebugger();
+    void setDebugger(Debugging::Debugger *debugger);
     void enableProfiler();
 
     ExecutionContext *pushGlobalContext();
diff --git a/tests/auto/qml/qv4debugger/tst_qv4debugger.cpp b/tests/auto/qml/qv4debugger/tst_qv4debugger.cpp
index 7772d16234..902ad50be7 100644
--- a/tests/auto/qml/qv4debugger/tst_qv4debugger.cpp
+++ b/tests/auto/qml/qv4debugger/tst_qv4debugger.cpp
@@ -158,7 +158,7 @@ public:
     }
 
 public slots:
-    void debuggerPaused(QV4::Debugging::Debugger *debugger, QV4::Debugging::PauseReason reason)
+    void debuggerPaused(V4Debugger *debugger, QV4::Debugging::PauseReason reason)
     {
         Q_ASSERT(debugger == m_debugger);
         Q_ASSERT(debugger->engine() == collector.engine());
@@ -166,7 +166,7 @@ public slots:
         m_pauseReason = reason;
         m_statesWhenPaused << debugger->currentExecutionState();
 
-        if (debugger->state() == QV4::Debugging::Debugger::Paused &&
+        if (debugger->state() == V4Debugger::Paused &&
                 debugger->engine()->hasException) {
             Refs refs;
             RefHolder holder(&collector, &refs);
@@ -183,7 +183,7 @@ public slots:
         m_stackTrace = debugger->stackTrace();
 
         while (!m_expressionRequests.isEmpty()) {
-            Q_ASSERT(debugger->state() == QV4::Debugging::Debugger::Paused);
+            Q_ASSERT(debugger->state() == V4Debugger::Paused);
             ExpressionRequest request = m_expressionRequests.takeFirst();
             m_expressionResults << Refs();
             RefHolder holder(&collector, &m_expressionResults.last());
@@ -195,7 +195,7 @@ public slots:
         if (m_captureContextInfo)
             captureContextInfo(debugger);
 
-        debugger->resume(Debugger::FullThrottle);
+        debugger->resume(V4Debugger::FullThrottle);
     }
 
 public:
@@ -208,7 +208,7 @@ public:
         int lineNumber;
     };
 
-    void captureContextInfo(Debugger *debugger)
+    void captureContextInfo(V4Debugger *debugger)
     {
         for (int i = 0, ei = m_stackTrace.size(); i != ei; ++i) {
             m_capturedArguments.append(NamedRefs(&collector));
@@ -225,20 +225,18 @@ public:
         }
     }
 
-    void addDebugger(QV4::Debugging::Debugger *debugger)
+    void addDebugger(V4Debugger *debugger)
     {
         Q_ASSERT(!m_debugger);
         m_debugger = debugger;
-        connect(m_debugger,
-                SIGNAL(debuggerPaused(QV4::Debugging::Debugger*,QV4::Debugging::PauseReason)),
-                this,
-                SLOT(debuggerPaused(QV4::Debugging::Debugger*,QV4::Debugging::PauseReason)));
+        connect(m_debugger, &V4Debugger::debuggerPaused,
+                this, &TestAgent::debuggerPaused);
     }
 
     bool m_wasPaused;
     PauseReason m_pauseReason;
     bool m_captureContextInfo;
-    QList<Debugger::ExecutionState> m_statesWhenPaused;
+    QList<V4Debugger::ExecutionState> m_statesWhenPaused;
     QList<TestBreakPoint> m_breakPointsToAddWhenPaused;
     QVector<QV4::StackFrame> m_stackTrace;
     QVector<NamedRefs> m_capturedArguments;
@@ -252,7 +250,7 @@ public:
     };
     QVector<ExpressionRequest> m_expressionRequests;
     QVector<Refs> m_expressionResults;
-    QV4::Debugging::Debugger *m_debugger;
+    V4Debugger *m_debugger;
 
     // Utility methods:
     void dumpStackTrace() const
@@ -296,6 +294,10 @@ private slots:
     void evaluateExpression();
 
 private:
+    V4Debugger *debugger() const
+    {
+        return static_cast<V4Debugger *>(m_v4->debugger);
+    }
     void evaluateJavaScript(const QString &script, const QString &fileName, int lineNumber = 1)
     {
         QMetaObject::invokeMethod(m_engine, "evaluate", Qt::QueuedConnection,
@@ -315,11 +317,11 @@ void tst_qv4debugger::init()
     m_javaScriptThread = new QThread;
     m_engine = new TestEngine;
     m_v4 = m_engine->v4Engine();
-    m_v4->enableDebugger();
+    m_v4->setDebugger(new V4Debugger(m_v4));
     m_engine->moveToThread(m_javaScriptThread);
     m_javaScriptThread->start();
     m_debuggerAgent = new TestAgent(m_v4);
-    m_debuggerAgent->addDebugger(m_v4->debugger);
+    m_debuggerAgent->addDebugger(debugger());
 }
 
 void tst_qv4debugger::cleanup()
@@ -340,7 +342,7 @@ void tst_qv4debugger::breakAnywhere()
             "var i = 42;\n"
             "var j = i + 1\n"
             "var k = i\n";
-    m_v4->debugger->pause();
+    debugger()->pause();
     evaluateJavaScript(script, "testFile");
     QVERIFY(m_debuggerAgent->m_wasPaused);
 }
@@ -351,11 +353,11 @@ void tst_qv4debugger::pendingBreakpoint()
             "var i = 42;\n"
             "var j = i + 1\n"
             "var k = i\n";
-    m_v4->debugger->addBreakPoint("testfile", 2);
+    debugger()->addBreakPoint("testfile", 2);
     evaluateJavaScript(script, "testfile");
     QVERIFY(m_debuggerAgent->m_wasPaused);
     QCOMPARE(m_debuggerAgent->m_statesWhenPaused.count(), 1);
-    QV4::Debugging::Debugger::ExecutionState state = m_debuggerAgent->m_statesWhenPaused.first();
+    V4Debugger::ExecutionState state = m_debuggerAgent->m_statesWhenPaused.first();
     QCOMPARE(state.fileName, QString("testfile"));
     QCOMPARE(state.lineNumber, 2);
 }
@@ -367,11 +369,11 @@ void tst_qv4debugger::liveBreakPoint()
             "var j = i + 1\n"
             "var k = i\n";
     m_debuggerAgent->m_breakPointsToAddWhenPaused << TestAgent::TestBreakPoint("liveBreakPoint", 3);
-    m_v4->debugger->pause();
+    debugger()->pause();
     evaluateJavaScript(script, "liveBreakPoint");
     QVERIFY(m_debuggerAgent->m_wasPaused);
     QCOMPARE(m_debuggerAgent->m_statesWhenPaused.count(), 2);
-    QV4::Debugging::Debugger::ExecutionState state = m_debuggerAgent->m_statesWhenPaused.at(1);
+    V4Debugger::ExecutionState state = m_debuggerAgent->m_statesWhenPaused.at(1);
     QCOMPARE(state.fileName, QString("liveBreakPoint"));
     QCOMPARE(state.lineNumber, 3);
 }
@@ -382,8 +384,8 @@ void tst_qv4debugger::removePendingBreakPoint()
             "var i = 42;\n"
             "var j = i + 1\n"
             "var k = i\n";
-    m_v4->debugger->addBreakPoint("removePendingBreakPoint", 2);
-    m_v4->debugger->removeBreakPoint("removePendingBreakPoint", 2);
+    debugger()->addBreakPoint("removePendingBreakPoint", 2);
+    debugger()->removeBreakPoint("removePendingBreakPoint", 2);
     evaluateJavaScript(script, "removePendingBreakPoint");
     QVERIFY(!m_debuggerAgent->m_wasPaused);
 }
@@ -394,13 +396,13 @@ void tst_qv4debugger::addBreakPointWhilePaused()
             "var i = 42;\n"
             "var j = i + 1\n"
             "var k = i\n";
-    m_v4->debugger->addBreakPoint("addBreakPointWhilePaused", 1);
+    debugger()->addBreakPoint("addBreakPointWhilePaused", 1);
     m_debuggerAgent->m_breakPointsToAddWhenPaused << TestAgent::TestBreakPoint("addBreakPointWhilePaused", 2);
     evaluateJavaScript(script, "addBreakPointWhilePaused");
     QVERIFY(m_debuggerAgent->m_wasPaused);
     QCOMPARE(m_debuggerAgent->m_statesWhenPaused.count(), 2);
 
-    QV4::Debugging::Debugger::ExecutionState state = m_debuggerAgent->m_statesWhenPaused.at(0);
+    V4Debugger::ExecutionState state = m_debuggerAgent->m_statesWhenPaused.at(0);
     QCOMPARE(state.fileName, QString("addBreakPointWhilePaused"));
     QCOMPARE(state.lineNumber, 1);
 
@@ -411,7 +413,8 @@ void tst_qv4debugger::addBreakPointWhilePaused()
 
 static QV4::ReturnedValue someCall(QV4::CallContext *ctx)
 {
-    ctx->d()->engine->debugger->removeBreakPoint("removeBreakPointForNextInstruction", 2);
+    static_cast<V4Debugger *>(ctx->d()->engine->debugger)
+            ->removeBreakPoint("removeBreakPointForNextInstruction", 2);
     return QV4::Encode::undefined();
 }
 
@@ -424,7 +427,7 @@ void tst_qv4debugger::removeBreakPointForNextInstruction()
     QMetaObject::invokeMethod(m_engine, "injectFunction", Qt::BlockingQueuedConnection,
                               Q_ARG(QString, "someCall"), Q_ARG(InjectedFunction, someCall));
 
-    m_v4->debugger->addBreakPoint("removeBreakPointForNextInstruction", 2);
+    debugger()->addBreakPoint("removeBreakPointForNextInstruction", 2);
 
     evaluateJavaScript(script, "removeBreakPointForNextInstruction");
     QVERIFY(!m_debuggerAgent->m_wasPaused);
@@ -441,11 +444,11 @@ void tst_qv4debugger::conditionalBreakPoint()
             "}\n"
             "test()\n";
 
-    m_v4->debugger->addBreakPoint("conditionalBreakPoint", 3, QStringLiteral("i > 10"));
+    debugger()->addBreakPoint("conditionalBreakPoint", 3, QStringLiteral("i > 10"));
     evaluateJavaScript(script, "conditionalBreakPoint");
     QVERIFY(m_debuggerAgent->m_wasPaused);
     QCOMPARE(m_debuggerAgent->m_statesWhenPaused.count(), 4);
-    QV4::Debugging::Debugger::ExecutionState state = m_debuggerAgent->m_statesWhenPaused.first();
+    V4Debugger::ExecutionState state = m_debuggerAgent->m_statesWhenPaused.first();
     QCOMPARE(state.fileName, QString("conditionalBreakPoint"));
     QCOMPARE(state.lineNumber, 3);
 
@@ -460,12 +463,13 @@ void tst_qv4debugger::conditionalBreakPointInQml()
 {
     QQmlEngine engine;
     QV4::ExecutionEngine *v4 = QV8Engine::getV4(&engine);
-    v4->enableDebugger();
+    V4Debugger *v4Debugger = new V4Debugger(v4);
+    v4->setDebugger(v4Debugger);
 
     QScopedPointer<QThread> debugThread(new QThread);
     debugThread->start();
     QScopedPointer<TestAgent> debuggerAgent(new TestAgent(v4));
-    debuggerAgent->addDebugger(v4->debugger);
+    debuggerAgent->addDebugger(v4Debugger);
     debuggerAgent->moveToThread(debugThread.data());
 
     QQmlComponent component(&engine);
@@ -479,7 +483,7 @@ void tst_qv4debugger::conditionalBreakPointInQml()
                       "    }\n"
                       "}\n", QUrl("test.qml"));
 
-    v4->debugger->addBreakPoint("test.qml", 7, "root.foo == 42");
+    v4Debugger->addBreakPoint("test.qml", 7, "root.foo == 42");
 
     QScopedPointer<QObject> obj(component.create());
     QCOMPARE(obj->property("success").toBool(), true);
@@ -501,7 +505,7 @@ void tst_qv4debugger::readArguments()
             "}\n"
             "var four;\n"
             "f(1, 'two', null, four);\n";
-    m_v4->debugger->addBreakPoint("readArguments", 2);
+    debugger()->addBreakPoint("readArguments", 2);
     evaluateJavaScript(script, "readArguments");
     QVERIFY(m_debuggerAgent->m_wasPaused);
     QVERIFY(m_debuggerAgent->m_capturedArguments.size() > 1);
@@ -525,7 +529,7 @@ void tst_qv4debugger::readLocals()
             "  return c === d\n"
             "}\n"
             "f(1, 2, 3);\n";
-    m_v4->debugger->addBreakPoint("readLocals", 3);
+    debugger()->addBreakPoint("readLocals", 3);
     evaluateJavaScript(script, "readLocals");
     QVERIFY(m_debuggerAgent->m_wasPaused);
     QVERIFY(m_debuggerAgent->m_capturedLocals.size() > 1);
@@ -547,7 +551,7 @@ void tst_qv4debugger::readObject()
             "  return b\n"
             "}\n"
             "f({head: 1, tail: { head: 'asdf', tail: null }});\n";
-    m_v4->debugger->addBreakPoint("readObject", 3);
+    debugger()->addBreakPoint("readObject", 3);
     evaluateJavaScript(script, "readObject");
     QVERIFY(m_debuggerAgent->m_wasPaused);
     QVERIFY(m_debuggerAgent->m_capturedLocals.size() > 1);
@@ -599,7 +603,7 @@ void tst_qv4debugger::readContextInAllFrames()
             "    return 1;\n" // breakpoint
             "}\n"
             "fact(12);\n";
-    m_v4->debugger->addBreakPoint("readFormalsInAllFrames", 7);
+    debugger()->addBreakPoint("readFormalsInAllFrames", 7);
     evaluateJavaScript(script, "readFormalsInAllFrames");
     QVERIFY(m_debuggerAgent->m_wasPaused);
     QCOMPARE(m_debuggerAgent->m_stackTrace.size(), 13);
@@ -634,7 +638,7 @@ void tst_qv4debugger::pauseOnThrow()
             "  throw n\n"
             "}\n"
             "die('hard');\n";
-    m_v4->debugger->setBreakOnThrow(true);
+    debugger()->setBreakOnThrow(true);
     evaluateJavaScript(script, "pauseOnThrow");
     QVERIFY(m_debuggerAgent->m_wasPaused);
     QCOMPARE(m_debuggerAgent->m_pauseReason, Throwing);
@@ -655,12 +659,12 @@ void tst_qv4debugger::breakInCatch()
             "    console.log(e, 'me');\n"
             "}\n";
 
-    m_v4->debugger->addBreakPoint("breakInCatch", 4);
+    debugger()->addBreakPoint("breakInCatch", 4);
     evaluateJavaScript(script, "breakInCatch");
     QVERIFY(m_debuggerAgent->m_wasPaused);
     QCOMPARE(m_debuggerAgent->m_pauseReason, BreakPoint);
     QCOMPARE(m_debuggerAgent->m_statesWhenPaused.count(), 1);
-    QV4::Debugging::Debugger::ExecutionState state = m_debuggerAgent->m_statesWhenPaused.first();
+    V4Debugger::ExecutionState state = m_debuggerAgent->m_statesWhenPaused.first();
     QCOMPARE(state.fileName, QString("breakInCatch"));
     QCOMPARE(state.lineNumber, 4);
 }
@@ -672,12 +676,12 @@ void tst_qv4debugger::breakInWith()
             "    console.log('give the answer');\n"
             "}\n";
 
-    m_v4->debugger->addBreakPoint("breakInWith", 2);
+    debugger()->addBreakPoint("breakInWith", 2);
     evaluateJavaScript(script, "breakInWith");
     QVERIFY(m_debuggerAgent->m_wasPaused);
     QCOMPARE(m_debuggerAgent->m_pauseReason, BreakPoint);
     QCOMPARE(m_debuggerAgent->m_statesWhenPaused.count(), 1);
-    QV4::Debugging::Debugger::ExecutionState state = m_debuggerAgent->m_statesWhenPaused.first();
+    V4Debugger::ExecutionState state = m_debuggerAgent->m_statesWhenPaused.first();
     QCOMPARE(state.fileName, QString("breakInWith"));
     QCOMPARE(state.lineNumber, 2);
 }
@@ -700,7 +704,7 @@ void tst_qv4debugger::evaluateExpression()
     request.frameNr = 1;
     m_debuggerAgent->m_expressionRequests << request;
 
-    m_v4->debugger->addBreakPoint("evaluateExpression", 3);
+    debugger()->addBreakPoint("evaluateExpression", 3);
 
     evaluateJavaScript(script, "evaluateExpression");