Move QV8Engine::to/fromVariant over to a v4 based API

Change-Id: Ie44de10cbd970715345e2c428db666dc6233b39c
Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>

16 files changed, 122 insertions, 116 deletions

diff --git a/src/imports/localstorage/plugin.cpp b/src/imports/localstorage/plugin.cpp
index be2f71e0ed..66c3365375 100644
--- a/src/imports/localstorage/plugin.cpp
+++ b/src/imports/localstorage/plugin.cpp
@@ -261,16 +261,16 @@ static v8::Handle<v8::Value> qmlsqldatabase_executeSql(const v8::Arguments& args
                 v8::Local<v8::Array> array = v8::Local<v8::Array>::Cast(values);
                 uint32_t size = array->Length();
                 for (uint32_t ii = 0; ii < size; ++ii)
-                    query.bindValue(ii, engine->toVariant(array->Get(ii), -1));
+                    query.bindValue(ii, engine->toVariant(array->Get(ii)->v4Value(), -1));
             } else if (values->IsObject() && !values->ToObject()->GetExternalResource()) {
                 v8::Local<v8::Object> object = values->ToObject();
                 v8::Local<v8::Array> names = object->GetPropertyNames();
                 uint32_t size = names->Length();
                 for (uint32_t ii = 0; ii < size; ++ii)
                     query.bindValue(names->Get(ii)->v4Value().toQString(),
-                                    engine->toVariant(object->Get(names->Get(ii)), -1));
+                                    engine->toVariant(object->Get(names->Get(ii))->v4Value(), -1));
             } else {
-                query.bindValue(0, engine->toVariant(values, -1));
+                query.bindValue(0, engine->toVariant(values->v4Value(), -1));
             }
         }
         if (query.exec()) {
diff --git a/src/imports/xmllistmodel/qqmlxmllistmodel.cpp b/src/imports/xmllistmodel/qqmlxmllistmodel.cpp
index 4d0c509b2d..668479f5ba 100644
--- a/src/imports/xmllistmodel/qqmlxmllistmodel.cpp
+++ b/src/imports/xmllistmodel/qqmlxmllistmodel.cpp
@@ -926,7 +926,7 @@ QQmlV4Handle QQuickXmlListModel::get(int index) const
     Object *o = v4engine->newObject();
     for (int ii = 0; ii < d->roleObjects.count(); ++ii) {
         Property *p = o->insertMember(v4engine->newIdentifier(d->roleObjects[ii]->name()), PropertyAttributes());
-        p->value = v8engine->fromVariant(d->data.value(ii).value(index)).get()->v4Value();
+        p->value = v8engine->fromVariant(d->data.value(ii).value(index));
     }
 
     return QQmlV4Handle::fromValue(Value::fromObject(o));
diff --git a/src/qml/qml/qqmlbinding.cpp b/src/qml/qml/qqmlbinding.cpp
index 12ab72e852..d9abd1f2f0 100644
--- a/src/qml/qml/qqmlbinding.cpp
+++ b/src/qml/qml/qqmlbinding.cpp
@@ -329,7 +329,7 @@ QVariant QQmlBinding::evaluate()
 
     ep->dereferenceScarceResources();
 
-    return ep->v8engine()->toVariant(result, qMetaTypeId<QList<QObject*> >());
+    return ep->v8engine()->toVariant(result->v4Value(), qMetaTypeId<QList<QObject*> >());
 }
 
 QString QQmlBinding::expressionIdentifier(QQmlJavaScriptExpression *e)
diff --git a/src/qml/qml/qqmlexpression.cpp b/src/qml/qml/qqmlexpression.cpp
index 3bc0c50ba4..e27a6651c4 100644
--- a/src/qml/qml/qqmlexpression.cpp
+++ b/src/qml/qml/qqmlexpression.cpp
@@ -379,7 +379,7 @@ QVariant QQmlExpressionPrivate::value(bool *isUndefined)
         v8::HandleScope handle_scope;
         v8::Context::Scope context_scope(ep->v8engine()->context());
         v8::Local<v8::Value> result = v8value(isUndefined);
-        rv = ep->v8engine()->toVariant(result, -1);
+        rv = ep->v8engine()->toVariant(result->v4Value(), -1);
     }
 
     ep->dereferenceScarceResources(); // "release" scarce resources if top-level expression evaluation is complete.
diff --git a/src/qml/qml/qqmllocale.cpp b/src/qml/qml/qqmllocale.cpp
index 52acd85c7a..54d4f36529 100644
--- a/src/qml/qml/qqmllocale.cpp
+++ b/src/qml/qml/qqmllocale.cpp
@@ -185,7 +185,7 @@ v8::Handle<v8::Value> QQmlDateExtension::toLocaleString(const v8::Arguments& arg
     QString formattedDt;
     if (args.Length() == 2) {
         if (args[1]->IsString()) {
-            QString format = r->engine->toVariant(args[1], -1).toString();
+            QString format = r->engine->toVariant(args[1]->v4Value(), -1).toString();
             formattedDt = r->locale.toString(dt, format);
         } else if (args[1]->IsNumber()) {
             quint32 intFormat = args[1]->ToNumber()->Value();
@@ -227,7 +227,7 @@ v8::Handle<v8::Value> QQmlDateExtension::toLocaleTimeString(const v8::Arguments&
     QString formattedTime;
     if (args.Length() == 2) {
         if (args[1]->IsString()) {
-            QString format = r->engine->toVariant(args[1], -1).toString();
+            QString format = r->engine->toVariant(args[1]->v4Value(), -1).toString();
             formattedTime = r->locale.toString(time, format);
         } else if (args[1]->IsNumber()) {
             quint32 intFormat = args[1]->ToNumber()->Value();
@@ -269,7 +269,7 @@ v8::Handle<v8::Value> QQmlDateExtension::toLocaleDateString(const v8::Arguments&
     QString formattedDate;
     if (args.Length() == 2) {
         if (args[1]->IsString()) {
-            QString format = r->engine->toVariant(args[1], -1).toString();
+            QString format = r->engine->toVariant(args[1]->v4Value(), -1).toString();
             formattedDate = r->locale.toString(date, format);
         } else if (args[1]->IsNumber()) {
             quint32 intFormat = args[1]->ToNumber()->Value();
diff --git a/src/qml/qml/qqmlproperty.cpp b/src/qml/qml/qqmlproperty.cpp
index 91effab027..583e243b3c 100644
--- a/src/qml/qml/qqmlproperty.cpp
+++ b/src/qml/qml/qqmlproperty.cpp
@@ -1538,13 +1538,13 @@ bool QQmlPropertyPrivate::writeBinding(QObject *object,
 
     if (isUndefined) {
     } else if (core.isQList()) {
-        value = v8engine->toVariant(result, qMetaTypeId<QList<QObject *> >());
+        value = v8engine->toVariant(result->v4Value(), qMetaTypeId<QList<QObject *> >());
     } else if (result->IsNull() && core.isQObject()) {
         value = QVariant::fromValue((QObject *)0);
     } else if (core.propType == qMetaTypeId<QList<QUrl> >()) {
-        value = resolvedUrlSequence(v8engine->toVariant(result, qMetaTypeId<QList<QUrl> >()), context);
+        value = resolvedUrlSequence(v8engine->toVariant(result->v4Value(), qMetaTypeId<QList<QUrl> >()), context);
     } else if (!isVarProperty && type != qMetaTypeId<QJSValue>()) {
-        value = v8engine->toVariant(result, type);
+        value = v8engine->toVariant(result->v4Value(), type);
     }
 
     if (expression->hasError()) {
diff --git a/src/qml/qml/qqmlvmemetaobject.cpp b/src/qml/qml/qqmlvmemetaobject.cpp
index fbdd3893ca..24c60bc9ad 100644
--- a/src/qml/qml/qqmlvmemetaobject.cpp
+++ b/src/qml/qml/qqmlvmemetaobject.cpp
@@ -954,7 +954,7 @@ int QQmlVMEMetaObject::metaCall(QMetaObject::Call c, int _id, void **a)
                         ep->warning(error);
                     if (a[0]) *(QVariant *)a[0] = QVariant();
                 } else {
-                    if (a[0]) *(QVariant *)a[0] = ep->v8engine()->toVariant(result, 0);
+                    if (a[0]) *(QVariant *)a[0] = ep->v8engine()->toVariant(result->v4Value(), 0);
                 }
 
                 ep->dereferenceScarceResources(); // "release" scarce resources if top-level expression evaluation is complete.
@@ -1011,7 +1011,7 @@ QVariant QQmlVMEMetaObject::readPropertyAsVariant(int id)
 {
     if (id >= firstVarPropertyIndex) {
         if (ensureVarPropertiesAllocated())
-            return QQmlEnginePrivate::get(ctxt->engine)->v8engine()->toVariant(varProperties->Get(id - firstVarPropertyIndex), -1);
+            return QQmlEnginePrivate::get(ctxt->engine)->v8engine()->toVariant(varProperties->Get(id - firstVarPropertyIndex)->v4Value(), -1);
         return QVariant();
     } else {
         if (data[id].dataType() == QMetaType::QObjectStar) {
diff --git a/src/qml/qml/v8/qqmlbuiltinfunctions.cpp b/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
index 938970919e..9ab2ac83c4 100644
--- a/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
+++ b/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
@@ -471,7 +471,7 @@ v8::Handle<v8::Value> colorEqual(const v8::Arguments &args)
 
     bool ok = false;
 
-    QVariant lhs = V8ENGINE()->toVariant(args[0], -1);
+    QVariant lhs = V8ENGINE()->toVariant(args[0]->v4Value(), -1);
     if (lhs.userType() == QVariant::String) {
         lhs = QQmlStringConverters::colorFromString(lhs.toString(), &ok);
         if (!ok) {
@@ -481,7 +481,7 @@ v8::Handle<v8::Value> colorEqual(const v8::Arguments &args)
         V8THROW_ERROR("Qt.colorEqual(): Invalid arguments");
     }
 
-    QVariant rhs = V8ENGINE()->toVariant(args[1], -1);
+    QVariant rhs = V8ENGINE()->toVariant(args[1]->v4Value(), -1);
     if (rhs.userType() == QVariant::String) {
         rhs = QQmlStringConverters::colorFromString(rhs.toString(), &ok);
         if (!ok) {
@@ -701,7 +701,7 @@ v8::Handle<v8::Value> lighter(const v8::Arguments &args)
     if (args.Length() != 1 && args.Length() != 2)
         V8THROW_ERROR("Qt.lighter(): Invalid arguments");
 
-    QVariant v = V8ENGINE()->toVariant(args[0], -1);
+    QVariant v = V8ENGINE()->toVariant(args[0]->v4Value(), -1);
     if (v.userType() == QVariant::String) {
         bool ok = false;
         v = QQmlStringConverters::colorFromString(v.toString(), &ok);
@@ -739,7 +739,7 @@ v8::Handle<v8::Value> darker(const v8::Arguments &args)
     if (args.Length() != 1 && args.Length() != 2)
         V8THROW_ERROR("Qt.darker(): Invalid arguments");
 
-    QVariant v = V8ENGINE()->toVariant(args[0], -1);
+    QVariant v = V8ENGINE()->toVariant(args[0]->v4Value(), -1);
     if (v.userType() == QVariant::String) {
         bool ok = false;
         v = QQmlStringConverters::colorFromString(v.toString(), &ok);
@@ -787,7 +787,7 @@ v8::Handle<v8::Value> tint(const v8::Arguments &args)
         V8THROW_ERROR("Qt.tint(): Invalid arguments");
 
     // base color
-    QVariant v1 = V8ENGINE()->toVariant(args[0], -1);
+    QVariant v1 = V8ENGINE()->toVariant(args[0]->v4Value(), -1);
     if (v1.userType() == QVariant::String) {
         bool ok = false;
         v1 = QQmlStringConverters::colorFromString(v1.toString(), &ok);
@@ -799,7 +799,7 @@ v8::Handle<v8::Value> tint(const v8::Arguments &args)
     }
 
     // tint color
-    QVariant v2 = V8ENGINE()->toVariant(args[1], -1);
+    QVariant v2 = V8ENGINE()->toVariant(args[1]->v4Value(), -1);
     if (v2.userType() == QVariant::String) {
         bool ok = false;
         v2 = QQmlStringConverters::colorFromString(v2.toString(), &ok);
@@ -835,11 +835,11 @@ v8::Handle<v8::Value> formatDate(const v8::Arguments &args)
         V8THROW_ERROR("Qt.formatDate(): Invalid arguments");
 
     Qt::DateFormat enumFormat = Qt::DefaultLocaleShortDate;
-    QDate date = V8ENGINE()->toVariant(args[0], -1).toDateTime().date();
+    QDate date = V8ENGINE()->toVariant(args[0]->v4Value(), -1).toDateTime().date();
     QString formattedDate;
     if (args.Length() == 2) {
         if (args[1]->IsString()) {
-            QString format = V8ENGINE()->toVariant(args[1], -1).toString();
+            QString format = V8ENGINE()->toVariant(args[1]->v4Value(), -1).toString();
             formattedDate = date.toString(format);
         } else if (args[1]->IsNumber()) {
             quint32 intFormat = args[1]->ToNumber()->Value();
@@ -875,7 +875,7 @@ v8::Handle<v8::Value> formatTime(const v8::Arguments &args)
     if (args.Length() < 1 || args.Length() > 2)
         V8THROW_ERROR("Qt.formatTime(): Invalid arguments");
 
-    QVariant argVariant = V8ENGINE()->toVariant(args[0], -1);
+    QVariant argVariant = V8ENGINE()->toVariant(args[0]->v4Value(), -1);
     QTime time;
     if (args[0]->IsDate() || (argVariant.type() == QVariant::String))
         time = argVariant.toDateTime().time();
@@ -886,7 +886,7 @@ v8::Handle<v8::Value> formatTime(const v8::Arguments &args)
     QString formattedTime;
     if (args.Length() == 2) {
         if (args[1]->IsString()) {
-            QString format = V8ENGINE()->toVariant(args[1], -1).toString();
+            QString format = V8ENGINE()->toVariant(args[1]->v4Value(), -1).toString();
             formattedTime = time.toString(format);
         } else if (args[1]->IsNumber()) {
             quint32 intFormat = args[1]->ToNumber()->Value();
@@ -998,11 +998,11 @@ v8::Handle<v8::Value> formatDateTime(const v8::Arguments &args)
         V8THROW_ERROR("Qt.formatDateTime(): Invalid arguments");
 
     Qt::DateFormat enumFormat = Qt::DefaultLocaleShortDate;
-    QDateTime dt = V8ENGINE()->toVariant(args[0], -1).toDateTime();
+    QDateTime dt = V8ENGINE()->toVariant(args[0]->v4Value(), -1).toDateTime();
     QString formattedDt;
     if (args.Length() == 2) {
         if (args[1]->IsString()) {
-            QString format = V8ENGINE()->toVariant(args[1], -1).toString();
+            QString format = V8ENGINE()->toVariant(args[1]->v4Value(), -1).toString();
             formattedDt = dt.toString(format);
         } else if (args[1]->IsNumber()) {
             quint32 intFormat = args[1]->ToNumber()->Value();
@@ -1027,7 +1027,7 @@ v8::Handle<v8::Value> openUrlExternally(const v8::Arguments &args)
     if (args.Length() != 1)
         return V8ENGINE()->fromVariant(false);
 
-    QUrl url(V8ENGINE()->toVariant(resolvedUrl(args), -1).toUrl());
+    QUrl url(V8ENGINE()->toVariant(resolvedUrl(args)->v4Value(), -1).toUrl());
     return V8ENGINE()->fromVariant(QQml_guiProvider()->openUrlExternally(url));
 }
 
@@ -1037,7 +1037,7 @@ v8::Handle<v8::Value> openUrlExternally(const v8::Arguments &args)
 */
 v8::Handle<v8::Value> resolvedUrl(const v8::Arguments &args)
 {
-    QUrl url = V8ENGINE()->toVariant(args[0], -1).toUrl();
+    QUrl url = V8ENGINE()->toVariant(args[0]->v4Value(), -1).toUrl();
     QQmlEngine *e = V8ENGINE()->engine();
     QQmlEnginePrivate *p = 0;
     if (e) p = QQmlEnginePrivate::get(e);
diff --git a/src/qml/qml/v8/qv8engine.cpp b/src/qml/qml/v8/qv8engine.cpp
index fb9ae4f6e5..2d3f1f5388 100644
--- a/src/qml/qml/v8/qv8engine.cpp
+++ b/src/qml/qml/v8/qv8engine.cpp
@@ -201,22 +201,22 @@ QV8Engine::~QV8Engine()
         qPersistentDispose(m_context);
 }
 
-QVariant QV8Engine::toVariant(v8::Handle<v8::Value> value, int typeHint)
+QVariant QV8Engine::toVariant(const QV4::Value &value, int typeHint)
 {
-    if (value.IsEmpty())
+    if (value.isDeleted())
         return QVariant();
 
     if (typeHint == QVariant::Bool)
-        return QVariant(value->BooleanValue());
+        return QVariant(value.toBoolean());
 
     if (typeHint == QMetaType::QJsonValue)
-        return QVariant::fromValue(jsonValueFromJS(value->v4Value()));
+        return QVariant::fromValue(jsonValueFromJS(value));
 
     if (typeHint == qMetaTypeId<QJSValue>())
-        return QVariant::fromValue(scriptValueFromInternal(value->v4Value()));
+        return QVariant::fromValue(scriptValueFromInternal(value));
 
-    if (value->IsObject()) {
-        QV8ObjectResource *r = (QV8ObjectResource *)value->ToObject()->GetExternalResource();
+    if (value.isObject()) {
+        QV8ObjectResource *r = (QV8ObjectResource *)v8::Handle<v8::Value>(value)->ToObject()->GetExternalResource();
         if (r) {
             switch (r->resourceType()) {
             case QV8ObjectResource::Context2DStyleType:
@@ -248,20 +248,19 @@ QVariant QV8Engine::toVariant(v8::Handle<v8::Value> value, int typeHint)
                 return m_sequenceWrapper.toVariant(r);
             }
         } else if (typeHint == QMetaType::QJsonObject
-                   && !value->IsArray() && !value->IsFunction()) {
-            return QVariant::fromValue(jsonObjectFromJS(value->v4Value()));
+                   && !value.asArrayObject() && !value.asFunctionObject()) {
+            return QVariant::fromValue(jsonObjectFromJS(value));
         }
     }
 
-    if (value->IsArray()) {
-        v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(value);
+    if (QV4::ArrayObject *a = value.asArrayObject()) {
         if (typeHint == qMetaTypeId<QList<QObject *> >()) {
             QList<QObject *> list;
-            uint32_t length = array->Length();
+            uint32_t length = a->arrayLength();
             for (uint32_t ii = 0; ii < length; ++ii) {
-                v8::Local<v8::Value> arrayItem = array->Get(ii);
-                if (arrayItem->IsObject()) {
-                    list << toQObject(arrayItem->ToObject()->v4Value());
+                QV4::Value arrayItem = a->getIndexed(m_v4Engine->current, ii);
+                if (arrayItem.isObject()) {
+                    list << toQObject(arrayItem);
                 } else {
                     list << 0;
                 }
@@ -269,11 +268,11 @@ QVariant QV8Engine::toVariant(v8::Handle<v8::Value> value, int typeHint)
 
             return qVariantFromValue<QList<QObject*> >(list);
         } else if (typeHint == QMetaType::QJsonArray) {
-            return QVariant::fromValue(jsonArrayFromJS(value->v4Value()));
+            return QVariant::fromValue(jsonArrayFromJS(value));
         }
 
         bool succeeded = false;
-        QVariant retn = m_sequenceWrapper.toVariant(array, typeHint, &succeeded);
+        QVariant retn = m_sequenceWrapper.toVariant(value, typeHint, &succeeded);
         if (succeeded)
             return retn;
     }
@@ -281,36 +280,42 @@ QVariant QV8Engine::toVariant(v8::Handle<v8::Value> value, int typeHint)
     return toBasicVariant(value);
 }
 
-static v8::Handle<v8::Array> arrayFromStringList(QV8Engine *engine, const QStringList &list)
+static QV4::Value arrayFromStringList(QV8Engine *engine, const QStringList &list)
 {
-    v8::Context::Scope scope(engine->context());
-    v8::Local<v8::Array> result = v8::Array::New(list.count());
-    for (int ii = 0; ii < list.count(); ++ii)
-        result->Set(ii, engine->toString(list.at(ii)));
-    return result;
+    QV4::ExecutionEngine *e = QV8Engine::getV4(engine);
+    QV4::ArrayObject *a = e->newArrayObject(e->current);
+    int len = list.count();
+    a->arrayReserve(len);
+    for (int ii = 0; ii < len; ++ii)
+        a->arrayData[ii].value = QV4::Value::fromString(e->newString(list.at(ii)));
+    a->setArrayLengthUnchecked(len);
+    return QV4::Value::fromObject(a);
 }
 
-static v8::Handle<v8::Array> arrayFromVariantList(QV8Engine *engine, const QVariantList &list)
+static QV4::Value arrayFromVariantList(QV8Engine *engine, const QVariantList &list)
 {
-    v8::Context::Scope scope(engine->context());
-    v8::Local<v8::Array> result = v8::Array::New(list.count());
-    for (int ii = 0; ii < list.count(); ++ii)
-        result->Set(ii, engine->fromVariant(list.at(ii)));
-    return result;
+    QV4::ExecutionEngine *e = QV8Engine::getV4(engine);
+    QV4::ArrayObject *a = e->newArrayObject(e->current);
+    int len = list.count();
+    a->arrayReserve(len);
+    for (int ii = 0; ii < len; ++ii)
+        a->arrayData[ii].value = engine->fromVariant(list.at(ii));
+    a->setArrayLengthUnchecked(len);
+    return QV4::Value::fromObject(a);
 }
 
-static v8::Handle<v8::Object> objectFromVariantMap(QV8Engine *engine, const QVariantMap &map)
+static QV4::Value objectFromVariantMap(QV8Engine *engine, const QVariantMap &map)
 {
-    v8::Context::Scope scope(engine->context());
-    v8::Local<v8::Object> object = v8::Object::New();
+    QV4::ExecutionEngine *e = QV8Engine::getV4(engine);
+    QV4::Object *o = e->newObject();
     for (QVariantMap::ConstIterator iter = map.begin(); iter != map.end(); ++iter)
-        object->Set(engine->toString(iter.key()), engine->fromVariant(iter.value()));
-    return object;
+        o->put(e->current, e->newString(iter.key()), engine->fromVariant(iter.value()));
+    return QV4::Value::fromObject(o);
 }
 
 Q_CORE_EXPORT QString qt_regexp_toCanonical(const QString &, QRegExp::PatternSyntax);
 
-v8::Handle<v8::Value> QV8Engine::fromVariant(const QVariant &variant)
+QV4::Value QV8Engine::fromVariant(const QVariant &variant)
 {
     int type = variant.userType();
     const void *ptr = variant.constData();
@@ -319,41 +324,44 @@ v8::Handle<v8::Value> QV8Engine::fromVariant(const QVariant &variant)
         switch (QMetaType::Type(type)) {
             case QMetaType::UnknownType:
             case QMetaType::Void:
-                return v8::Undefined();
+                return QV4::Value::undefinedValue();
             case QMetaType::Bool:
-                return v8::Boolean::New(*reinterpret_cast<const bool*>(ptr));
+                return QV4::Value::fromBoolean(*reinterpret_cast<const bool*>(ptr));
             case QMetaType::Int:
-                return v8::Integer::New(*reinterpret_cast<const int*>(ptr));
+                return QV4::Value::fromInt32(*reinterpret_cast<const int*>(ptr));
             case QMetaType::UInt:
-                return v8::Integer::NewFromUnsigned(*reinterpret_cast<const uint*>(ptr));
+                return QV4::Value::fromUInt32(*reinterpret_cast<const uint*>(ptr));
             case QMetaType::LongLong:
-                return v8::Number::New(*reinterpret_cast<const qlonglong*>(ptr));
+                return QV4::Value::fromDouble(*reinterpret_cast<const qlonglong*>(ptr));
             case QMetaType::ULongLong:
-                return v8::Number::New(*reinterpret_cast<const qulonglong*>(ptr));
+                return QV4::Value::fromDouble(*reinterpret_cast<const qulonglong*>(ptr));
             case QMetaType::Double:
-                return v8::Number::New(*reinterpret_cast<const double*>(ptr));
+                return QV4::Value::fromDouble(*reinterpret_cast<const double*>(ptr));
             case QMetaType::QString:
-                return v8::Value::fromV4Value(QV4::Value::fromString(m_v4Engine->current, *reinterpret_cast<const QString*>(ptr)));
+                return QV4::Value::fromString(m_v4Engine->current, *reinterpret_cast<const QString*>(ptr));
             case QMetaType::Float:
-                return v8::Number::New(*reinterpret_cast<const float*>(ptr));
+                return QV4::Value::fromDouble(*reinterpret_cast<const float*>(ptr));
             case QMetaType::Short:
-                return v8::Integer::New(*reinterpret_cast<const short*>(ptr));
+                return QV4::Value::fromInt32(*reinterpret_cast<const short*>(ptr));
             case QMetaType::UShort:
-                return v8::Integer::NewFromUnsigned(*reinterpret_cast<const unsigned short*>(ptr));
+                return QV4::Value::fromUInt32(*reinterpret_cast<const unsigned short*>(ptr));
             case QMetaType::Char:
-                return v8::Integer::New(*reinterpret_cast<const char*>(ptr));
+                return QV4::Value::fromInt32(*reinterpret_cast<const char*>(ptr));
             case QMetaType::UChar:
-                return v8::Integer::NewFromUnsigned(*reinterpret_cast<const unsigned char*>(ptr));
+                return QV4::Value::fromUInt32(*reinterpret_cast<const unsigned char*>(ptr));
             case QMetaType::QChar:
-                return v8::Integer::New((*reinterpret_cast<const QChar*>(ptr)).unicode());
+                return QV4::Value::fromInt32((*reinterpret_cast<const QChar*>(ptr)).unicode());
             case QMetaType::QDateTime:
-                return v8::Date::New(qtDateTimeToJsDate(*reinterpret_cast<const QDateTime *>(ptr)));
+                return QV4::Value::fromObject(m_v4Engine->newDateObject(QV4::Value::fromDouble(
+                                            qtDateTimeToJsDate(*reinterpret_cast<const QDateTime *>(ptr)))));
             case QMetaType::QDate:
-                return v8::Date::New(qtDateTimeToJsDate(QDateTime(*reinterpret_cast<const QDate *>(ptr))));
+                return QV4::Value::fromObject(m_v4Engine->newDateObject(QV4::Value::fromDouble(
+                                            qtDateTimeToJsDate(QDateTime(*reinterpret_cast<const QDate *>(ptr))))));
             case QMetaType::QTime:
-                return v8::Date::New(qtDateTimeToJsDate(QDateTime(QDate(1970,1,1), *reinterpret_cast<const QTime *>(ptr))));
+            return QV4::Value::fromObject(m_v4Engine->newDateObject(QV4::Value::fromDouble(
+                                            qtDateTimeToJsDate(QDateTime(QDate(1970,1,1), *reinterpret_cast<const QTime *>(ptr))))));
             case QMetaType::QRegExp:
-                return QJSConverter::toRegExp(*reinterpret_cast<const QRegExp *>(ptr));
+                return QJSConverter::toRegExp(*reinterpret_cast<const QRegExp *>(ptr))->v4Value();
             case QMetaType::QObjectStar:
                 return newQObject(*reinterpret_cast<QObject* const *>(ptr));
             case QMetaType::QStringList:
@@ -361,7 +369,7 @@ v8::Handle<v8::Value> QV8Engine::fromVariant(const QVariant &variant)
                 bool succeeded = false;
                 v8::Handle<v8::Value> retn = m_sequenceWrapper.fromVariant(variant, &succeeded);
                 if (succeeded)
-                    return retn;
+                    return retn->v4Value();
                 return arrayFromStringList(this, *reinterpret_cast<const QStringList *>(ptr));
                 }
             case QMetaType::QVariantList:
@@ -369,34 +377,32 @@ v8::Handle<v8::Value> QV8Engine::fromVariant(const QVariant &variant)
             case QMetaType::QVariantMap:
                 return objectFromVariantMap(this, *reinterpret_cast<const QVariantMap *>(ptr));
             case QMetaType::QJsonValue:
-                return v8::Value::fromV4Value(jsonValueToJS(*reinterpret_cast<const QJsonValue *>(ptr)));
+                return jsonValueToJS(*reinterpret_cast<const QJsonValue *>(ptr));
             case QMetaType::QJsonObject:
-                return v8::Value::fromV4Value(jsonObjectToJS(*reinterpret_cast<const QJsonObject *>(ptr)));
+                return jsonObjectToJS(*reinterpret_cast<const QJsonObject *>(ptr));
             case QMetaType::QJsonArray:
-                return v8::Value::fromV4Value(jsonArrayToJS(*reinterpret_cast<const QJsonArray *>(ptr)));
+                return jsonArrayToJS(*reinterpret_cast<const QJsonArray *>(ptr));
 
             default:
                 break;
         }
 
         if (QQmlValueType *vt = QQmlValueTypeFactory::valueType(type))
-            return m_valueTypeWrapper.newValueType(variant, vt);
+            return m_valueTypeWrapper.newValueType(variant, vt)->v4Value();
     } else {
         if (type == qMetaTypeId<QQmlListReference>()) {
             typedef QQmlListReferencePrivate QDLRP;
             QDLRP *p = QDLRP::get((QQmlListReference*)ptr);
             if (p->object) {
-                return m_listWrapper.newList(p->property, p->propertyType);
+                return m_listWrapper.newList(p->property, p->propertyType)->v4Value();
             } else {
-                return v8::Null();
+                return QV4::Value::nullValue();
             }
         } else if (type == qMetaTypeId<QJSValue>()) {
             const QJSValue *value = reinterpret_cast<const QJSValue *>(ptr);
             QJSValuePrivate *valuep = QJSValuePrivate::get(*value);
             valuep->engine = m_v4Engine;
-                return v8::Local<v8::Value>::New(v8::Value::fromV4Value(valuep->getValue(valuep->engine)));
-//            if (valuep->assignEngine(this))
-//                return v8::Local<v8::Value>::New(*valuep);
+            return valuep->getValue(valuep->engine);
         } else if (type == qMetaTypeId<QList<QObject *> >()) {
             // XXX Can this be made more by using Array as a prototype and implementing
             // directly against QList<QObject*>?
@@ -404,7 +410,7 @@ v8::Handle<v8::Value> QV8Engine::fromVariant(const QVariant &variant)
             v8::Local<v8::Array> array = v8::Array::New(list.count());
             for (int ii = 0; ii < list.count(); ++ii)
                 array->Set(ii, newQObject(list.at(ii)));
-            return array;
+            return array->v4Value();
         }
 
         bool objOk;
@@ -415,17 +421,17 @@ v8::Handle<v8::Value> QV8Engine::fromVariant(const QVariant &variant)
         bool succeeded = false;
         v8::Handle<v8::Value> retn = m_sequenceWrapper.fromVariant(variant, &succeeded);
         if (succeeded)
-            return retn;
+            return retn->v4Value();
 
         if (QQmlValueType *vt = QQmlValueTypeFactory::valueType(type))
-            return m_valueTypeWrapper.newValueType(variant, vt);
+            return m_valueTypeWrapper.newValueType(variant, vt)->v4Value();
     }
 
     // XXX TODO: To be compatible, we still need to handle:
     //    + QObjectList
     //    + QList<int>
 
-    return m_variantWrapper.newVariant(variant);
+    return m_variantWrapper.newVariant(variant)->v4Value();
 }
 
 // A handle scope and context must be entered
@@ -532,7 +538,7 @@ QVariant QV8Engine::toBasicVariant(v8::Handle<v8::Value> value)
         v8::Handle<v8::Array> array = v8::Handle<v8::Array>::Cast(value);
         int length = array->Length();
         for (int ii = 0; ii < length; ++ii)
-            rv << toVariant(array->Get(ii), -1);
+            rv << toVariant(array->Get(ii)->v4Value(), -1);
         return rv;
     }
     if (!value->IsFunction()) {
diff --git a/src/qml/qml/v8/qv8engine_p.h b/src/qml/qml/v8/qv8engine_p.h
index f7e73a0393..7e9f809858 100644
--- a/src/qml/qml/v8/qv8engine_p.h
+++ b/src/qml/qml/v8/qv8engine_p.h
@@ -306,8 +306,8 @@ public:
 
     static inline bool startsWithUpper(QV4::String *);
 
-    QVariant toVariant(v8::Handle<v8::Value>, int typeHint);
-    v8::Handle<v8::Value> fromVariant(const QVariant &);
+    QVariant toVariant(const QV4::Value &value, int typeHint);
+    QV4::Value fromVariant(const QVariant &);
     inline bool isVariant(v8::Handle<v8::Value>);
 
     // Compile \a source (from \a fileName at \a lineNumber) in QML mode
diff --git a/src/qml/qml/v8/qv8qobjectwrapper.cpp b/src/qml/qml/v8/qv8qobjectwrapper.cpp
index b4acd0c534..a435bf1819 100644
--- a/src/qml/qml/v8/qv8qobjectwrapper.cpp
+++ b/src/qml/qml/v8/qv8qobjectwrapper.cpp
@@ -685,9 +685,9 @@ static inline void StoreProperty(QV8Engine *engine, QObject *object, QQmlPropert
     } else {
         QVariant v;
         if (property->isQList()) 
-            v = engine->toVariant(value, qMetaTypeId<QList<QObject *> >());
+            v = engine->toVariant(value->v4Value(), qMetaTypeId<QList<QObject *> >());
         else
-            v = engine->toVariant(value, property->propType);
+            v = engine->toVariant(value->v4Value(), property->propType);
 
         QQmlContextData *context = engine->callingContext();
         if (!QQmlPropertyPrivate::write(object, *property, v, context)) {
@@ -1722,12 +1722,12 @@ static int MatchScore(v8::Handle<v8::Value> actual, int conversionType)
         } else if (r && r->resourceType() == QV8ObjectResource::VariantType) {
             if (conversionType == qMetaTypeId<QVariant>())
                 return 0;
-            else if (r->engine->toVariant(actual, -1).userType() == conversionType)
+            else if (r->engine->toVariant(actual->v4Value(), -1).userType() == conversionType)
                 return 0;
             else
                 return 10;
         } else if (r && r->resourceType() == QV8ObjectResource::ValueTypeType) {
-            if (r->engine->toVariant(actual, -1).userType() == conversionType)
+            if (r->engine->toVariant(actual->v4Value(), -1).userType() == conversionType)
                 return 0;
             return 10;
         } else if (conversionType == QMetaType::QJsonObject) {
@@ -2171,7 +2171,7 @@ void CallArgument::fromValue(int callType, QV8Engine *engine, v8::Handle<v8::Val
         qobjectPtr = engine->toQObject(value->v4Value());
         type = callType;
     } else if (callType == qMetaTypeId<QVariant>()) {
-        qvariantPtr = new (&allocData) QVariant(engine->toVariant(value, -1));
+        qvariantPtr = new (&allocData) QVariant(engine->toVariant(value->v4Value(), -1));
         type = callType;
     } else if (callType == qMetaTypeId<QList<QObject*> >()) {
         qlistPtr = new (&allocData) QList<QObject *>();
@@ -2203,7 +2203,7 @@ void CallArgument::fromValue(int callType, QV8Engine *engine, v8::Handle<v8::Val
         type = -1;
 
         QQmlEnginePrivate *ep = engine->engine() ? QQmlEnginePrivate::get(engine->engine()) : 0;
-        QVariant v = engine->toVariant(value, -1); // why -1 instead of callType?
+        QVariant v = engine->toVariant(value->v4Value(), -1); // why -1 instead of callType?
 
         if (v.userType() == callType) {
             *qvariantPtr = v;
@@ -2212,7 +2212,7 @@ void CallArgument::fromValue(int callType, QV8Engine *engine, v8::Handle<v8::Val
             qvariantPtr->convert(callType);
         } else if (engine->sequenceWrapper()->isSequenceType(callType) && v.userType() == qMetaTypeId<QVariantList>()) {
             // convert the JS array to a sequence of the correct type.
-            QVariant seqV = engine->toVariant(value, callType);
+            QVariant seqV = engine->toVariant(value->v4Value(), callType);
             *qvariantPtr = seqV;
         } else {
             QQmlMetaObject mo = ep ? ep->rawMetaObjectForType(callType) : QQmlMetaObject();
diff --git a/src/qml/qml/v8/qv8valuetypewrapper.cpp b/src/qml/qml/v8/qv8valuetypewrapper.cpp
index 30fe193137..13476b8db0 100644
--- a/src/qml/qml/v8/qv8valuetypewrapper.cpp
+++ b/src/qml/qml/v8/qv8valuetypewrapper.cpp
@@ -414,7 +414,7 @@ v8::Handle<v8::Value> QV8ValueTypeWrapper::Setter(v8::Local<v8::String> property
             oldBinding->destroy();
 
         if (!value->IsFunction()) {
-            QVariant v = r->engine->toVariant(value, -1);
+            QVariant v = r->engine->toVariant(value->v4Value(), -1);
 
             if (p.isEnumType() && (QMetaType::Type)v.type() == QMetaType::Double)
                 v = v.toInt();
@@ -438,7 +438,7 @@ v8::Handle<v8::Value> QV8ValueTypeWrapper::Setter(v8::Local<v8::String> property
         if (index == -1)
             return value;
 
-        QVariant v = r->engine->toVariant(value, -1);
+        QVariant v = r->engine->toVariant(value->v4Value(), -1);
 
         r->type->setValue(copy->value);
         QMetaProperty p = r->type->metaObject()->property(index);
diff --git a/src/qml/types/qqmldelegatemodel.cpp b/src/qml/types/qqmldelegatemodel.cpp
index eb9914c794..98955f959b 100644
--- a/src/qml/types/qqmldelegatemodel.cpp
+++ b/src/qml/types/qqmldelegatemodel.cpp
@@ -1529,7 +1529,7 @@ bool QQmlDelegateModelPrivate::insert(
         v8::Local<v8::String> propertyName = propertyNames->Get(i)->ToString();
         cacheItem->setValue(
                 propertyName->v4Value().toQString(),
-                m_cacheMetaType->v8Engine->toVariant(object->Get(propertyName), QVariant::Invalid));
+                m_cacheMetaType->v8Engine->toVariant(object->Get(propertyName)->v4Value(), QVariant::Invalid));
     }
 
     cacheItem->groups = groups | Compositor::UnresolvedFlag | Compositor::CacheFlag;
diff --git a/src/qml/util/qqmladaptormodel.cpp b/src/qml/util/qqmladaptormodel.cpp
index 5b6ef79338..35cc2170ac 100644
--- a/src/qml/util/qqmladaptormodel.cpp
+++ b/src/qml/util/qqmladaptormodel.cpp
@@ -361,10 +361,10 @@ void QQmlDMCachedModelData::set_property(
         QQmlDMCachedModelData *modelData = static_cast<QQmlDMCachedModelData *>(data);
         if (!modelData->cachedData.isEmpty()) {
             if (modelData->cachedData.count() > 1) {
-                modelData->cachedData[propertyId] = data->engine->toVariant(value, QVariant::Invalid);
+                modelData->cachedData[propertyId] = data->engine->toVariant(value->v4Value(), QVariant::Invalid);
                 QMetaObject::activate(data, data->metaObject(), propertyId, 0);
             } else if (modelData->cachedData.count() == 1) {
-                modelData->cachedData[0] = data->engine->toVariant(value, QVariant::Invalid);
+                modelData->cachedData[0] = data->engine->toVariant(value->v4Value(), QVariant::Invalid);
                 QMetaObject::activate(data, data->metaObject(), 0, 0);
                 QMetaObject::activate(data, data->metaObject(), 1, 0);
             }
@@ -596,7 +596,7 @@ public:
         V8ASSERT_TYPE_SETTER(data, "Not a valid VisualData object");
 
         static_cast<QQmlDMListAccessorData *>(data)->setModelData(
-                data->engine->toVariant(value, QVariant::Invalid));
+                data->engine->toVariant(value->v4Value(), QVariant::Invalid));
     }
 
     v8::Handle<v8::Value> get()
diff --git a/src/qmltest/quicktestresult.cpp b/src/qmltest/quicktestresult.cpp
index 9fcb60488c..d8e0f3f84b 100644
--- a/src/qmltest/quicktestresult.cpp
+++ b/src/qmltest/quicktestresult.cpp
@@ -488,7 +488,7 @@ void QuickTestResult::stringify(QQmlV8Function *args)
     && !value->IsArray()
     && !value->IsDate()
     && !value->IsRegExp()) {
-        QVariant v = engine->toVariant(value, QMetaType::UnknownType);
+        QVariant v = engine->toVariant(value->v4Value(), QMetaType::UnknownType);
         if (v.isValid()) {
             switch (v.type()) {
             case QVariant::Vector3D:
diff --git a/src/quick/items/context2d/qquickcontext2d.cpp b/src/quick/items/context2d/qquickcontext2d.cpp
index 1ab6c4a4e2..a3652c4132 100644
--- a/src/quick/items/context2d/qquickcontext2d.cpp
+++ b/src/quick/items/context2d/qquickcontext2d.cpp
@@ -846,7 +846,7 @@ static void ctx2d_fillStyle_set(v8::Local<v8::String>, v8::Local<v8::Value> valu
     QV8Engine *engine = V8ENGINE_ACCESSOR();
 
    if (value->IsObject()) {
-       QColor color = engine->toVariant(value, qMetaTypeId<QColor>()).value<QColor>();
+       QColor color = engine->toVariant(value->v4Value(), qMetaTypeId<QColor>()).value<QColor>();
        if (color.isValid()) {
            r->context->state.fillStyle = color;
            r->context->buffer()->setFillStyle(color);
@@ -949,7 +949,7 @@ static void ctx2d_strokeStyle_set(v8::Local<v8::String>, v8::Local<v8::Value> va
     QV8Engine *engine = V8ENGINE_ACCESSOR();
 
     if (value->IsObject()) {
-        QColor color = engine->toVariant(value, qMetaTypeId<QColor>()).value<QColor>();
+        QColor color = engine->toVariant(value->v4Value(), qMetaTypeId<QColor>()).value<QColor>();
         if (color.isValid()) {
             r->context->state.fillStyle = color;
             r->context->buffer()->setStrokeStyle(color);
@@ -1181,7 +1181,7 @@ static v8::Handle<v8::Value> ctx2d_createPattern(const v8::Arguments &args)
         QQuickContext2DEngineData *ed = engineData(engine);
         QV8Context2DStyleResource *styleResouce = new QV8Context2DStyleResource(engine);
 
-        QColor color = engine->toVariant(args[0], qMetaTypeId<QColor>()).value<QColor>();
+        QColor color = engine->toVariant(args[0]->v4Value(), qMetaTypeId<QColor>()).value<QColor>();
         if (color.isValid()) {
             int patternMode = args[1]->IntegerValue();
             Qt::BrushStyle style = Qt::SolidPattern;
@@ -2716,7 +2716,7 @@ static v8::Handle<v8::Value> ctx2d_gradient_addColorStop(const v8::Arguments &ar
         QColor color;
 
         if (args[1]->IsObject()) {
-            color = engine->toVariant(args[1], qMetaTypeId<QColor>()).value<QColor>();
+            color = engine->toVariant(args[1]->v4Value(), qMetaTypeId<QColor>()).value<QColor>();
         } else {
             color = qt_color_from_string(args[1]);
         }