Start cleaning up the QmlContextWrapper

The class should get merged with the QV4::QmlContext class.
Simplify the cleanup by moving both classes into a common
file.

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

13 files changed, 465 insertions, 100 deletions

diff --git a/src/qml/jsruntime/jsruntime.pri b/src/qml/jsruntime/jsruntime.pri
index dcc04cbd54..0c55200c64 100644
--- a/src/qml/jsruntime/jsruntime.pri
+++ b/src/qml/jsruntime/jsruntime.pri
@@ -27,6 +27,7 @@ SOURCES += \
     $$PWD/qv4numberobject.cpp \
     $$PWD/qv4object.cpp \
     $$PWD/qv4objectproto.cpp \
+    $$PWD/qv4qmlcontext.cpp \
     $$PWD/qv4regexpobject.cpp \
     $$PWD/qv4stringobject.cpp \
     $$PWD/qv4variantobject.cpp \
@@ -48,7 +49,6 @@ HEADERS += \
     $$PWD/qv4global_p.h \
     $$PWD/qv4engine_p.h \
     $$PWD/qv4context_p.h \
-    $$PWD/qv4context_p_p.h \
     $$PWD/qv4math_p.h \
     $$PWD/qv4persistent_p.h \
     $$PWD/qv4debugging_p.h \
@@ -73,6 +73,7 @@ HEADERS += \
     $$PWD/qv4numberobject_p.h \
     $$PWD/qv4object_p.h \
     $$PWD/qv4objectproto_p.h \
+    $$PWD/qv4qmlcontext_p.h \
     $$PWD/qv4regexpobject_p.h \
     $$PWD/qv4stringobject_p.h \
     $$PWD/qv4variantobject_p.h \
diff --git a/src/qml/jsruntime/qv4context.cpp b/src/qml/jsruntime/qv4context.cpp
index 390a5e7d7a..361d321a1a 100644
--- a/src/qml/jsruntime/qv4context.cpp
+++ b/src/qml/jsruntime/qv4context.cpp
@@ -39,7 +39,7 @@
 
 #include <QString>
 #include "qv4debugging_p.h"
-#include <qv4context_p_p.h>
+#include <qv4context_p.h>
 #include <qv4object_p.h>
 #include <qv4objectproto_p.h>
 #include <private/qv4mm_p.h>
@@ -47,6 +47,7 @@
 #include "qv4function_p.h"
 #include "qv4errorobject_p.h"
 #include "qv4string_p.h"
+#include "qv4qmlcontext_p.h"
 
 using namespace QV4;
 
@@ -55,7 +56,6 @@ DEFINE_MANAGED_VTABLE(CallContext);
 DEFINE_MANAGED_VTABLE(WithContext);
 DEFINE_MANAGED_VTABLE(CatchContext);
 DEFINE_MANAGED_VTABLE(GlobalContext);
-DEFINE_MANAGED_VTABLE(QmlContext);
 
 Heap::CallContext *ExecutionContext::newCallContext(const FunctionObject *function, CallData *callData)
 {
@@ -102,20 +102,6 @@ Heap::CatchContext *ExecutionContext::newCatchContext(Heap::String *exceptionVar
     return d()->engine->memoryManager->alloc<CatchContext>(d(), exceptionVarName, e);
 }
 
-Heap::QmlContext *ExecutionContext::newQmlContext(QmlContextWrapper *qml)
-{
-    Heap::QmlContext *c = d()->engine->memoryManager->alloc<QmlContext>(this, qml);
-    return c;
-}
-
-Heap::QmlContext *ExecutionContext::newQmlContext(QQmlContextData *context, QObject *scopeObject)
-{
-    Scope scope(this);
-    Scoped<QmlContextWrapper> qml(scope, QmlContextWrapper::qmlScope(scope.engine, context, scopeObject));
-    Heap::QmlContext *c = d()->engine->memoryManager->alloc<QmlContext>(this, qml);
-    return c;
-}
-
 void ExecutionContext::createMutableBinding(String *name, bool deletable)
 {
     Scope scope(this);
@@ -182,19 +168,6 @@ void Heap::CatchContext::init(ExecutionContext *outerContext, String *exceptionV
     this->exceptionValue = exceptionValue;
 }
 
-void Heap::QmlContext::init(QV4::ExecutionContext *outerContext, QV4::QmlContextWrapper *qml)
-{
-    Heap::ExecutionContext::init(outerContext->engine(), Heap::ExecutionContext::Type_QmlContext);
-    outer = outerContext->d();
-    strictMode = false;
-    callData = outer->callData;
-    lookups = outer->lookups;
-    constantTable = outer->constantTable;
-    compilationUnit = outer->compilationUnit;
-
-    this->qml = qml->d();
-}
-
 
 Identifier * const *CallContext::formals() const
 {
diff --git a/src/qml/jsruntime/qv4context_p.h b/src/qml/jsruntime/qv4context_p.h
index 3bad1f03d7..487917df7d 100644
--- a/src/qml/jsruntime/qv4context_p.h
+++ b/src/qml/jsruntime/qv4context_p.h
@@ -55,8 +55,8 @@
 
 QT_BEGIN_NAMESPACE
 
-class QQmlContextData;
 class QObject;
+class QQmlContextData;
 
 namespace QV4 {
 
@@ -65,11 +65,12 @@ struct CompilationUnit;
 struct Function;
 }
 
-struct QmlContextWrapper;
 struct Identifier;
 struct CallContext;
 struct CatchContext;
 struct WithContext;
+struct QmlContext;
+struct QmlContextWrapper;
 
 struct CallData
 {
@@ -91,6 +92,8 @@ struct CallData
 
 namespace Heap {
 
+struct QmlContext;
+
 struct ExecutionContext : Base {
     enum ContextType {
         Type_GlobalContext = 0x1,
@@ -177,14 +180,6 @@ struct WithContext : ExecutionContext {
 };
 V4_ASSERT_IS_TRIVIAL(WithContext)
 
-struct QmlContextWrapper;
-
-struct QmlContext : ExecutionContext {
-    void init(QV4::ExecutionContext *outerContext, QV4::QmlContextWrapper *qml);
-
-    Pointer<QmlContextWrapper> qml;
-};
-
 }
 
 struct Q_QML_EXPORT ExecutionContext : public Managed
@@ -201,8 +196,6 @@ struct Q_QML_EXPORT ExecutionContext : public Managed
     Heap::CallContext *newCallContext(const FunctionObject *f, CallData *callData);
     Heap::WithContext *newWithContext(Heap::Object *with);
     Heap::CatchContext *newCatchContext(Heap::String *exceptionVarName, ReturnedValue exceptionValue);
-    Heap::QmlContext *newQmlContext(QmlContextWrapper *qml);
-    Heap::QmlContext *newQmlContext(QQmlContextData *context, QObject *scopeObject);
 
     void createMutableBinding(String *name, bool deletable);
 
@@ -268,16 +261,6 @@ struct WithContext : public ExecutionContext
     V4_MANAGED(WithContext, ExecutionContext)
 };
 
-struct Q_QML_EXPORT QmlContext : public ExecutionContext
-{
-    V4_MANAGED(QmlContext, ExecutionContext)
-
-    QObject *qmlScope() const;
-    QQmlContextData *qmlContext() const;
-
-    void takeContextOwnership();
-};
-
 inline CallContext *ExecutionContext::asCallContext()
 {
     return d()->type >= Heap::ExecutionContext::Type_SimpleCallContext ? static_cast<CallContext *>(this) : 0;
diff --git a/src/qml/jsruntime/qv4engine.cpp b/src/qml/jsruntime/qv4engine.cpp
index 5c79c4ea97..698c73a910 100644
--- a/src/qml/jsruntime/qv4engine.cpp
+++ b/src/qml/jsruntime/qv4engine.cpp
@@ -37,7 +37,7 @@
 **
 ****************************************************************************/
 #include <qv4engine_p.h>
-#include <qv4context_p.h>
+#include <qv4qmlcontext_p.h>
 #include <qv4value_p.h>
 #include <qv4object_p.h>
 #include <qv4objectproto_p.h>
@@ -71,7 +71,6 @@
 #include "qv4typedarray_p.h"
 #include <private/qv8engine_p.h>
 #include <private/qjsvalue_p.h>
-#include <private/qqmlcontextwrapper_p.h>
 #include <private/qqmltypewrapper_p.h>
 #include <private/qqmlvaluetypewrapper_p.h>
 #include <private/qqmlvaluetype_p.h>
@@ -714,6 +713,27 @@ Heap::Object *ExecutionEngine::newForEachIteratorObject(Object *o)
     return obj->d();
 }
 
+Heap::QmlContext *ExecutionEngine::qmlContext() const
+{
+    Heap::ExecutionContext *ctx = current;
+
+    // get the correct context when we're within a builtin function
+    if (ctx->type == Heap::ExecutionContext::Type_SimpleCallContext && !ctx->outer)
+        ctx = parentContext(currentContext)->d();
+
+    if (ctx->type != Heap::ExecutionContext::Type_QmlContext && !ctx->outer)
+        return 0;
+
+    while (ctx->outer && ctx->outer->type != Heap::ExecutionContext::Type_GlobalContext)
+        ctx = ctx->outer;
+
+    Q_ASSERT(ctx);
+    if (ctx->type != Heap::ExecutionContext::Type_QmlContext)
+        return 0;
+
+    return static_cast<Heap::QmlContext *>(ctx);
+}
+
 QObject *ExecutionEngine::qmlScopeObject() const
 {
     Heap::QmlContext *ctx = qmlContext();
diff --git a/src/qml/jsruntime/qv4engine_p.h b/src/qml/jsruntime/qv4engine_p.h
index 64bf77b1f5..bf6898001f 100644
--- a/src/qml/jsruntime/qv4engine_p.h
+++ b/src/qml/jsruntime/qv4engine_p.h
@@ -548,27 +548,6 @@ inline ExecutionContext *ExecutionEngine::parentContext(ExecutionContext *contex
     return o ? context - o : 0;
 }
 
-inline Heap::QmlContext *ExecutionEngine::qmlContext() const
-{
-    Heap::ExecutionContext *ctx = current;
-
-    // get the correct context when we're within a builtin function
-    if (ctx->type == Heap::ExecutionContext::Type_SimpleCallContext && !ctx->outer)
-        ctx = parentContext(currentContext)->d();
-
-    if (ctx->type != Heap::ExecutionContext::Type_QmlContext && !ctx->outer)
-        return 0;
-
-    while (ctx->outer && ctx->outer->type != Heap::ExecutionContext::Type_GlobalContext)
-        ctx = ctx->outer;
-
-    Q_ASSERT(ctx);
-    if (ctx->type != Heap::ExecutionContext::Type_QmlContext)
-        return 0;
-
-    return static_cast<Heap::QmlContext *>(ctx);
-}
-
 inline
 void Heap::Base::mark(QV4::ExecutionEngine *engine)
 {
diff --git a/src/qml/jsruntime/qv4functionobject.cpp b/src/qml/jsruntime/qv4functionobject.cpp
index ee2fe6bfd7..28a9949464 100644
--- a/src/qml/jsruntime/qv4functionobject.cpp
+++ b/src/qml/jsruntime/qv4functionobject.cpp
@@ -208,7 +208,7 @@ Heap::FunctionObject *FunctionObject::createQmlFunction(QQmlContextData *qmlCont
     ExecutionEngine *engine = QQmlEnginePrivate::getV4Engine(qmlContext->engine);
     QV4::Scope valueScope(engine);
     ExecutionContext *global = valueScope.engine->rootContext();
-    QV4::Scoped<QmlContext> wrapperContext(valueScope, global->newQmlContext(qmlContext, scopeObject));
+    QV4::Scoped<QmlContext> wrapperContext(valueScope, QmlContext::create(global, qmlContext, scopeObject));
 
     if (!signalParameters.isEmpty()) {
         if (error)
diff --git a/src/qml/jsruntime/qv4include.cpp b/src/qml/jsruntime/qv4include.cpp
index be8057e9f5..1d393cf0aa 100644
--- a/src/qml/jsruntime/qv4include.cpp
+++ b/src/qml/jsruntime/qv4include.cpp
@@ -53,7 +53,6 @@
 #include <private/qv4functionobject_p.h>
 #include <private/qv4script_p.h>
 #include <private/qv4context_p.h>
-#include <private/qqmlcontextwrapper_p.h>
 
 QT_BEGIN_NAMESPACE
 
diff --git a/src/qml/jsruntime/qv4qmlcontext.cpp b/src/qml/jsruntime/qv4qmlcontext.cpp
new file mode 100644
index 0000000000..a4ace4c3eb
--- /dev/null
+++ b/src/qml/jsruntime/qv4qmlcontext.cpp
@@ -0,0 +1,362 @@
+/****************************************************************************
+**
+** 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 "qv4qmlcontext_p.h"
+#include <private/qv8engine_p.h>
+
+#include <private/qqmlengine_p.h>
+#include <private/qqmlcontext_p.h>
+
+#include <private/qv4engine_p.h>
+#include <private/qv4value_p.h>
+#include <private/qv4objectproto_p.h>
+#include <private/qv4mm_p.h>
+#include <private/qv4function_p.h>
+#include <private/qv4compileddata_p.h>
+#include <private/qqmltypewrapper_p.h>
+#include <private/qqmllistwrapper_p.h>
+#include <private/qqmljavascriptexpression_p.h>
+#include <private/qjsvalue_p.h>
+#include <private/qv4qobjectwrapper_p.h>
+
+QT_BEGIN_NAMESPACE
+
+using namespace QV4;
+
+DEFINE_OBJECT_VTABLE(QmlContextWrapper);
+DEFINE_MANAGED_VTABLE(QmlContext);
+
+void Heap::QmlContextWrapper::init(QQmlContextData *context, QObject *scopeObject, bool ownsContext)
+{
+    Object::init();
+    readOnly = true;
+    this->ownsContext = ownsContext;
+    isNullWrapper = false;
+    this->context = new QQmlGuardedContextData(context);
+    this->scopeObject.init(scopeObject);
+}
+
+void Heap::QmlContextWrapper::destroy()
+{
+    if (*context && ownsContext)
+        (*context)->destroy();
+    delete context;
+    scopeObject.destroy();
+    Object::destroy();
+}
+
+ReturnedValue QmlContextWrapper::qmlScope(ExecutionEngine *v4, QQmlContextData *ctxt, QObject *scope)
+{
+    Scope valueScope(v4);
+
+    Scoped<QmlContextWrapper> w(valueScope, v4->memoryManager->allocObject<QmlContextWrapper>(ctxt, scope));
+    return w.asReturnedValue();
+}
+
+ReturnedValue QmlContextWrapper::urlScope(ExecutionEngine *v4, const QUrl &url)
+{
+    Scope scope(v4);
+
+    QQmlContextData *context = new QQmlContextData;
+    context->baseUrl = url;
+    context->baseUrlString = url.toString();
+    context->isInternal = true;
+    context->isJSContext = true;
+
+    Scoped<QmlContextWrapper> w(scope, v4->memoryManager->allocObject<QmlContextWrapper>(context, (QObject*)0, true));
+    w->d()->isNullWrapper = true;
+    return w.asReturnedValue();
+}
+
+ReturnedValue QmlContextWrapper::get(const Managed *m, String *name, bool *hasProperty)
+{
+    Q_ASSERT(m->as<QmlContextWrapper>());
+    const QmlContextWrapper *resource = static_cast<const QmlContextWrapper *>(m);
+    QV4::ExecutionEngine *v4 = resource->engine();
+    QV4::Scope scope(v4);
+
+    // In V8 the JS global object would come _before_ the QML global object,
+    // so simulate that here.
+    bool hasProp;
+    QV4::ScopedValue result(scope, v4->globalObject->get(name, &hasProp));
+    if (hasProp) {
+        if (hasProperty)
+            *hasProperty = hasProp;
+        return result->asReturnedValue();
+    }
+
+    if (resource->d()->isNullWrapper)
+        return Object::get(m, name, hasProperty);
+
+    if (v4->callingQmlContext() != *resource->d()->context)
+        return Object::get(m, name, hasProperty);
+
+    result = Object::get(m, name, &hasProp);
+    if (hasProp) {
+        if (hasProperty)
+            *hasProperty = hasProp;
+        return result->asReturnedValue();
+    }
+
+    // Its possible we could delay the calculation of the "actual" context (in the case
+    // of sub contexts) until it is definately needed.
+    QQmlContextData *context = resource->getContext();
+    QQmlContextData *expressionContext = context;
+
+    if (!context) {
+        if (hasProperty)
+            *hasProperty = true;
+        return result->asReturnedValue();
+    }
+
+    // Search type (attached property/enum/imported scripts) names
+    // while (context) {
+    //     Search context properties
+    //     Search scope object
+    //     Search context object
+    //     context = context->parent
+    // }
+
+    QObject *scopeObject = resource->getScopeObject();
+
+    if (context->imports && name->startsWithUpper()) {
+        // Search for attached properties, enums and imported scripts
+        QQmlTypeNameCache::Result r = context->imports->query(name);
+
+        if (r.isValid()) {
+            if (hasProperty)
+                *hasProperty = true;
+            if (r.scriptIndex != -1) {
+                QV4::ScopedObject scripts(scope, context->importedScripts.valueRef());
+                return scripts->getIndexed(r.scriptIndex);
+            } else if (r.type) {
+                return QmlTypeWrapper::create(v4, scopeObject, r.type);
+            } else if (r.importNamespace) {
+                return QmlTypeWrapper::create(v4, scopeObject, context->imports, r.importNamespace);
+            }
+            Q_ASSERT(!"Unreachable");
+        }
+
+        // Fall through
+    }
+
+    QQmlEnginePrivate *ep = QQmlEnginePrivate::get(v4->qmlEngine());
+
+    while (context) {
+        // Search context properties
+        const QV4::IdentifierHash<int> &properties = context->propertyNames();
+        if (properties.count()) {
+            int propertyIdx = properties.value(name);
+
+            if (propertyIdx != -1) {
+
+                if (propertyIdx < context->idValueCount) {
+
+                    if (ep->propertyCapture)
+                        ep->propertyCapture->captureProperty(&context->idValues[propertyIdx].bindings);
+                    if (hasProperty)
+                        *hasProperty = true;
+                    return QV4::QObjectWrapper::wrap(v4, context->idValues[propertyIdx]);
+                } else {
+
+                    QQmlContextPrivate *cp = context->asQQmlContextPrivate();
+
+                    if (ep->propertyCapture)
+                        ep->propertyCapture->captureProperty(context->asQQmlContext(), -1, propertyIdx + cp->notifyIndex);
+
+                    const QVariant &value = cp->propertyValues.at(propertyIdx);
+                    if (hasProperty)
+                        *hasProperty = true;
+                    if (value.userType() == qMetaTypeId<QList<QObject*> >()) {
+                        QQmlListProperty<QObject> prop(context->asQQmlContext(), (void*) qintptr(propertyIdx),
+                                                               QQmlContextPrivate::context_count,
+                                                               QQmlContextPrivate::context_at);
+                        return QmlListWrapper::create(v4, prop, qMetaTypeId<QQmlListProperty<QObject> >());
+                    } else {
+                        return scope.engine->fromVariant(cp->propertyValues.at(propertyIdx));
+                    }
+                }
+            }
+        }
+
+        // Search scope object
+        if (scopeObject) {
+            bool hasProp = false;
+            QV4::ScopedValue result(scope, QV4::QObjectWrapper::getQmlProperty(v4, context, scopeObject,
+                                                                               name, QV4::QObjectWrapper::CheckRevision, &hasProp));
+            if (hasProp) {
+                if (hasProperty)
+                    *hasProperty = true;
+                return result->asReturnedValue();
+            }
+        }
+        scopeObject = 0;
+
+
+        // Search context object
+        if (context->contextObject) {
+            bool hasProp = false;
+            result = QV4::QObjectWrapper::getQmlProperty(v4, context, context->contextObject, name, QV4::QObjectWrapper::CheckRevision, &hasProp);
+            if (hasProp) {
+                if (hasProperty)
+                    *hasProperty = true;
+                return result->asReturnedValue();
+            }
+        }
+
+        context = context->parent;
+    }
+
+    expressionContext->unresolvedNames = true;
+
+    return Encode::undefined();
+}
+
+void QmlContextWrapper::put(Managed *m, String *name, const Value &value)
+{
+    Q_ASSERT(m->as<QmlContextWrapper>());
+    QmlContextWrapper *resource = static_cast<QmlContextWrapper *>(m);
+    ExecutionEngine *v4 = resource->engine();
+    QV4::Scope scope(v4);
+    if (scope.hasException())
+        return;
+    QV4::Scoped<QmlContextWrapper> wrapper(scope, resource);
+
+    uint member = wrapper->internalClass()->find(name);
+    if (member < UINT_MAX) {
+        wrapper->putValue(member, value);
+        return;
+    }
+
+    if (wrapper->d()->isNullWrapper) {
+        if (wrapper && wrapper->d()->readOnly) {
+            QString error = QLatin1String("Invalid write to global property \"") + name->toQString() +
+                            QLatin1Char('"');
+            ScopedString e(scope, v4->newString(error));
+            v4->throwError(e);
+            return;
+        }
+
+        Object::put(m, name, value);
+        return;
+    }
+
+    // Its possible we could delay the calculation of the "actual" context (in the case
+    // of sub contexts) until it is definately needed.
+    QQmlContextData *context = wrapper->getContext();
+    QQmlContextData *expressionContext = context;
+
+    if (!context)
+        return;
+
+    // See QV8ContextWrapper::Getter for resolution order
+
+    QObject *scopeObject = wrapper->getScopeObject();
+
+    while (context) {
+        const QV4::IdentifierHash<int> &properties = context->propertyNames();
+        // Search context properties
+        if (properties.count() && properties.value(name) != -1)
+            return;
+
+        // Search scope object
+        if (scopeObject &&
+            QV4::QObjectWrapper::setQmlProperty(v4, context, scopeObject, name, QV4::QObjectWrapper::CheckRevision, value))
+            return;
+        scopeObject = 0;
+
+        // Search context object
+        if (context->contextObject &&
+            QV4::QObjectWrapper::setQmlProperty(v4, context, context->contextObject, name, QV4::QObjectWrapper::CheckRevision, value))
+            return;
+
+        context = context->parent;
+    }
+
+    expressionContext->unresolvedNames = true;
+
+    if (wrapper->d()->readOnly) {
+        QString error = QLatin1String("Invalid write to global property \"") + name->toQString() +
+                        QLatin1Char('"');
+        v4->throwError(error);
+        return;
+    }
+
+    Object::put(m, name, value);
+}
+
+void Heap::QmlContext::init(QV4::ExecutionContext *outerContext, QV4::QmlContextWrapper *qml)
+{
+    Heap::ExecutionContext::init(outerContext->engine(), Heap::ExecutionContext::Type_QmlContext);
+    outer = outerContext->d();
+    strictMode = false;
+    callData = outer->callData;
+    lookups = outer->lookups;
+    constantTable = outer->constantTable;
+    compilationUnit = outer->compilationUnit;
+
+    this->qml = qml->d();
+}
+
+Heap::QmlContext *QmlContext::createWorkerContext(ExecutionContext *parent, const QUrl &source, Value *sendFunction)
+{
+    Scope scope(parent);
+
+    QV4::Scoped<QV4::QmlContextWrapper> qml(scope, QV4::QmlContextWrapper::urlScope(scope.engine, source));
+    Q_ASSERT(!!qml);
+
+    qml->setReadOnly(false);
+    QV4::ScopedObject api(scope, scope.engine->newObject());
+    api->put(QV4::ScopedString(scope, scope.engine->newString(QStringLiteral("sendMessage"))), *sendFunction);
+    qml->QV4::Object::put(QV4::ScopedString(scope, scope.engine->newString(QStringLiteral("WorkerScript"))), api);
+    qml->setReadOnly(true);
+
+    Heap::QmlContext *c = parent->d()->engine->memoryManager->alloc<QmlContext>(parent, qml);
+    return c;
+}
+
+Heap::QmlContext *QmlContext::create(ExecutionContext *parent, QQmlContextData *context, QObject *scopeObject)
+{
+    Scope scope(parent);
+    Scoped<QmlContextWrapper> qml(scope, QmlContextWrapper::qmlScope(scope.engine, context, scopeObject));
+    Heap::QmlContext *c = parent->d()->engine->memoryManager->alloc<QmlContext>(parent, qml);
+    return c;
+}
+
+QT_END_NAMESPACE
diff --git a/src/qml/jsruntime/qv4context_p_p.h b/src/qml/jsruntime/qv4qmlcontext_p.h
index ca8dc0b518..15a0aafbe8 100644
--- a/src/qml/jsruntime/qv4context_p_p.h
+++ b/src/qml/jsruntime/qv4qmlcontext_p.h
@@ -36,8 +36,9 @@
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
-#ifndef QV4CONTEXT_P_P_H
-#define QV4CONTEXT_P_P_H
+
+#ifndef QV4QMLCONTEXT_P_H
+#define QV4QMLCONTEXT_P_H
 
 //
 //  W A R N I N G
@@ -50,34 +51,83 @@
 // We mean it.
 //
 
-// This header defines a couple of inlinable methods.
-// These implementation cannot be put in qv4context_p.h, because they rely on the
-// QQmlContextWrapper, which in turn is a QV4::Object subclass (so it includes qv4object_p.h),
-// which includes qv4engine_p.h, that needs to include qv4context_p.h
+#include <QtCore/qglobal.h>
+#include <private/qtqmlglobal_p.h>
 
-#include "qv4context_p.h"
-#include "private/qqmlcontextwrapper_p.h"
+#include <private/qv4object_p.h>
+#include <private/qv4context_p.h>
+#include <private/qqmlcontext_p.h>
 
 QT_BEGIN_NAMESPACE
 
 namespace QV4 {
 
-QObject *QmlContext::qmlScope() const
-{
-    return d()->qml->scopeObject;
+struct QmlContextWrapper;
+
+namespace Heap {
+
+struct QmlContextWrapper : Object {
+    void init(QQmlContextData *context, QObject *scopeObject, bool ownsContext = false);
+    void destroy();
+    bool readOnly;
+    bool ownsContext;
+    bool isNullWrapper;
+
+    QQmlGuardedContextData *context;
+    QQmlQPointer<QObject> scopeObject;
+};
+
+struct QmlContext : ExecutionContext {
+    void init(QV4::ExecutionContext *outerContext, QV4::QmlContextWrapper *qml);
+
+    Pointer<QmlContextWrapper> qml;
+};
+
 }
 
-QQmlContextData *QmlContext::qmlContext() const
+struct Q_QML_EXPORT QmlContextWrapper : Object
 {
-    return *d()->qml->context;
-}
+    V4_OBJECT2(QmlContextWrapper, Object)
+    V4_NEEDS_DESTROY
 
-void QmlContext::takeContextOwnership() {
-    d()->qml->ownsContext = true;
-}
+    static ReturnedValue qmlScope(ExecutionEngine *e, QQmlContextData *ctxt, QObject *scope);
+    static ReturnedValue urlScope(ExecutionEngine *v4, const QUrl &);
+
+    void takeContextOwnership() {
+        d()->ownsContext = true;
+    }
 
-} // QV4 namespace
+    inline QObject *getScopeObject() const { return d()->scopeObject; }
+    inline QQmlContextData *getContext() const { return *d()->context; }
+
+    void setReadOnly(bool b) { d()->readOnly = b; }
+
+    static ReturnedValue get(const Managed *m, String *name, bool *hasProperty);
+    static void put(Managed *m, String *name, const Value &value);
+};
+
+struct Q_QML_EXPORT QmlContext : public ExecutionContext
+{
+    V4_MANAGED(QmlContext, ExecutionContext)
+
+    static Heap::QmlContext *createWorkerContext(QV4::ExecutionContext *parent, const QUrl &source, Value *sendFunction);
+    static Heap::QmlContext *create(QV4::ExecutionContext *parent, QQmlContextData *context, QObject *scopeObject);
+
+    QObject *qmlScope() const {
+        return d()->qml->scopeObject;
+    }
+    QQmlContextData *qmlContext() const {
+        return *d()->qml->context;
+    }
+
+    void takeContextOwnership() {
+        d()->qml->ownsContext = true;
+    }
+};
+
+}
 
 QT_END_NAMESPACE
 
-#endif // QV4CONTEXT_P_P_H
+#endif
+
diff --git a/src/qml/jsruntime/qv4qobjectwrapper.cpp b/src/qml/jsruntime/qv4qobjectwrapper.cpp
index 80607f4067..7ded931af3 100644
--- a/src/qml/jsruntime/qv4qobjectwrapper.cpp
+++ b/src/qml/jsruntime/qv4qobjectwrapper.cpp
@@ -48,7 +48,6 @@
 #include <private/qqmlglobal_p.h>
 #include <private/qqmltypewrapper_p.h>
 #include <private/qqmlvaluetypewrapper_p.h>
-#include <private/qqmlcontextwrapper_p.h>
 #include <private/qqmllistwrapper_p.h>
 #include <private/qqmlbuiltinfunctions_p.h>
 #include <private/qv8engine_p.h>
diff --git a/src/qml/jsruntime/qv4runtime.cpp b/src/qml/jsruntime/qv4runtime.cpp
index 61ef168447..b71bd4146a 100644
--- a/src/qml/jsruntime/qv4runtime.cpp
+++ b/src/qml/jsruntime/qv4runtime.cpp
@@ -53,7 +53,7 @@
 #include "qv4numberobject_p.h"
 #include "private/qlocale_tools_p.h"
 #include "qv4scopedvalue_p.h"
-#include <private/qqmlcontextwrapper_p.h>
+#include <private/qv4qmlcontext_p.h>
 #include <private/qqmltypewrapper_p.h>
 #include <private/qqmlengine_p.h>
 #include <private/qqmljavascriptexpression_p.h>
diff --git a/src/qml/jsruntime/qv4script.cpp b/src/qml/jsruntime/qv4script.cpp
index 787047806a..8c27d36f50 100644
--- a/src/qml/jsruntime/qv4script.cpp
+++ b/src/qml/jsruntime/qv4script.cpp
@@ -54,7 +54,6 @@
 #include <private/qv4profiling_p.h>
 #include <qv4jsir_p.h>
 #include <qv4codegen_p.h>
-#include <private/qqmlcontextwrapper_p.h>
 
 #include <QtCore/QDebug>
 #include <QtCore/QString>
diff --git a/src/qml/jsruntime/qv4script_p.h b/src/qml/jsruntime/qv4script_p.h
index 2e87a7692b..686fa49c88 100644
--- a/src/qml/jsruntime/qv4script_p.h
+++ b/src/qml/jsruntime/qv4script_p.h
@@ -53,7 +53,7 @@
 #include "qv4global_p.h"
 #include "qv4engine_p.h"
 #include "qv4functionobject_p.h"
-#include "qv4context_p.h"
+#include "qv4qmlcontext_p.h"
 
 #include <QQmlError>