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

Change-Id: I278524d0f43d2237201d9cf78c1c36a5ecc83d84

14 files changed, 283 insertions, 271 deletions

diff --git a/src/imports/folderlistmodel/folderlistmodel.pro b/src/imports/folderlistmodel/folderlistmodel.pro
index c29f1f8ca5..c8c805adb6 100644
--- a/src/imports/folderlistmodel/folderlistmodel.pro
+++ b/src/imports/folderlistmodel/folderlistmodel.pro
@@ -3,7 +3,7 @@ TARGET  = qmlfolderlistmodelplugin
 TARGETPATH = Qt/labs/folderlistmodel
 IMPORT_VERSION = 2.0
 
-QT = core-private qml-private v8-private
+QT = core-private qml-private
 
 SOURCES += qquickfolderlistmodel.cpp plugin.cpp \
     fileinfothread.cpp
diff --git a/src/imports/localstorage/localstorage.pro b/src/imports/localstorage/localstorage.pro
index c783404d0a..15753263b8 100644
--- a/src/imports/localstorage/localstorage.pro
+++ b/src/imports/localstorage/localstorage.pro
@@ -3,7 +3,7 @@ TARGET  = qmllocalstorageplugin
 TARGETPATH = QtQuick/LocalStorage
 IMPORT_VERSION = 2.0
 
-QT = sql qml-private v8-private core-private
+QT = sql qml-private  core-private
 
 SOURCES += plugin.cpp
 
diff --git a/src/imports/localstorage/plugin.cpp b/src/imports/localstorage/plugin.cpp
index 4877c4cfca..452a3d3127 100644
--- a/src/imports/localstorage/plugin.cpp
+++ b/src/imports/localstorage/plugin.cpp
@@ -54,34 +54,27 @@
 #include <QtCore/qcryptographichash.h>
 #include <QtCore/qsettings.h>
 #include <QtCore/qdir.h>
-#include <private/qv8sqlerrors_p.h>
-
-
-#define V8THROW_SQL(error, desc) \
-{ \
-    v8::Local<v8::Value> v = v8::Exception::Error(engine->toString(desc)); \
-    v->ToObject()->Set(v8::String::New("code"), v8::Integer::New(error)); \
-    v8::ThrowException(v); \
-    return v8::Handle<v8::Value>(); \
-}
-
-#define V8THROW_SQL_VOID(error, desc) \
-{ \
-    v8::Local<v8::Value> v = v8::Exception::Error(engine->toString(desc)); \
-    v->ToObject()->Set(v8::String::New("code"), v8::Integer::New(error)); \
-    v8::ThrowException(v); \
-    return; \
+#include <private/qv4sqlerrors_p.h>
+#include <private/qv4engine_p.h>
+#include <private/qv4object_p.h>
+#include <private/qv4functionobject_p.h>
+#include <private/qv4objectproto_p.h>
+#include <private/qv4exception_p.h>
+
+using namespace QV4;
+
+#define V4THROW_SQL(error, desc) { \
+    Value v = Value::fromString(ctx, desc); \
+    Object *ex = ctx->engine->newErrorObject(v); \
+    ex->put(ctx->engine->newIdentifier(QStringLiteral("code")), Value::fromInt32(error)); \
+    ctx->throwError(Value::fromObject(ex)); \
 }
 
-#define V8THROW_REFERENCE(string) { \
-    v8::ThrowException(v8::Exception::ReferenceError(v8::String::New(string))); \
-    return v8::Handle<v8::Value>(); \
+#define V4THROW_REFERENCE(string) { \
+    Value v = Value::fromString(ctx, string); \
+    ctx->throwReferenceError(v); \
 }
 
-#define V8THROW_REFERENCE_VOID(string) { \
-    v8::ThrowException(v8::Exception::ReferenceError(v8::String::New(string))); \
-    return; \
-}
 
 class QQmlSqlDatabaseData : public QV8Engine::Deletable
 {
@@ -89,23 +82,32 @@ public:
     QQmlSqlDatabaseData(QV8Engine *engine);
     ~QQmlSqlDatabaseData();
 
-    v8::Persistent<v8::Function> constructor;
-    v8::Persistent<v8::Function> queryConstructor;
-    v8::Persistent<v8::Function> rowsConstructor;
+    PersistentValue databaseProto;
+    PersistentValue queryProto;
+    PersistentValue rowsProto;
 };
 
 V8_DEFINE_EXTENSION(QQmlSqlDatabaseData, databaseData)
 
-class QV8SqlDatabaseResource : public QV8ObjectResource
+class QQmlSqlDatabaseWrapper : public Object
 {
-    V8_RESOURCE_TYPE(SQLDatabaseType)
+    Q_MANAGED
 
 public:
     enum Type { Database, Query, Rows };
-    QV8SqlDatabaseResource(QV8Engine *e)
-    : QV8ObjectResource(e), type(Database), inTransaction(false), readonly(false), forwardOnly(false) {}
+    QQmlSqlDatabaseWrapper(QV8Engine *e)
+        : Object(QV8Engine::getV4(e)), type(Database), inTransaction(false), readonly(false), forwardOnly(false)
+    {
+        vtbl = &static_vtbl;
+        prototype = QV8Engine::getV4(e)->objectPrototype;
+    }
+
+    ~QQmlSqlDatabaseWrapper() {
+    }
 
-    ~QV8SqlDatabaseResource() {
+    static Value getIndexed(Managed *m, uint index, bool *hasProperty);
+    static void destroy(Managed *that) {
+        static_cast<QQmlSqlDatabaseWrapper *>(that)->~QQmlSqlDatabaseWrapper();
     }
 
     Type type;
@@ -116,62 +118,61 @@ public:
     bool inTransaction; // type == Query
     bool readonly;   // type == Query
 
-    QSqlQuery query; // type == Rows
+    QSqlQuery sqlQuery; // type == Rows
     bool forwardOnly; // type == Rows
 };
 
-static v8::Handle<v8::Value> qmlsqldatabase_version(v8::Local<v8::String> /* property */, const v8::AccessorInfo& info)
+DEFINE_MANAGED_VTABLE(QQmlSqlDatabaseWrapper);
+
+static Value qmlsqldatabase_version(SimpleCallContext *ctx)
 {
-    QV8SqlDatabaseResource *r = v8_resource_cast<QV8SqlDatabaseResource>(info.This());
-    if (!r || r->type != QV8SqlDatabaseResource::Database)
-        V8THROW_REFERENCE("Not a SQLDatabase object");
+    QQmlSqlDatabaseWrapper *r = ctx->thisObject.as<QQmlSqlDatabaseWrapper>();
+    if (!r || r->type != QQmlSqlDatabaseWrapper::Database)
+        V4THROW_REFERENCE("Not a SQLDatabase object");
 
-    return r->engine->toString(r->version);
+    return Value::fromString(ctx->engine->newString(r->version));
 }
 
-static v8::Handle<v8::Value> qmlsqldatabase_rows_length(v8::Local<v8::String> /* property */, const v8::AccessorInfo& info)
+static Value qmlsqldatabase_rows_length(SimpleCallContext *ctx)
 {
-    QV8SqlDatabaseResource *r = v8_resource_cast<QV8SqlDatabaseResource>(info.This());
-    if (!r || r->type != QV8SqlDatabaseResource::Rows)
-        V8THROW_REFERENCE("Not a SQLDatabase::Rows object");
+    QQmlSqlDatabaseWrapper *r = ctx->thisObject.as<QQmlSqlDatabaseWrapper>();
+    if (!r || r->type != QQmlSqlDatabaseWrapper::Rows)
+        V4THROW_REFERENCE("Not a SQLDatabase::Rows object");
 
-    int s = r->query.size();
+    int s = r->sqlQuery.size();
     if (s < 0) {
         // Inefficient
-        if (r->query.last()) {
-            s = r->query.at() + 1;
+        if (r->sqlQuery.last()) {
+            s = r->sqlQuery.at() + 1;
         } else {
             s = 0;
         }
     }
-    return v8::Integer::New(s);
+    return Value::fromInt32(s);
 }
 
-static v8::Handle<v8::Value> qmlsqldatabase_rows_forwardOnly(v8::Local<v8::String> /* property */,
-                                                             const v8::AccessorInfo& info)
+static Value qmlsqldatabase_rows_forwardOnly(SimpleCallContext *ctx)
 {
-    QV8SqlDatabaseResource *r = v8_resource_cast<QV8SqlDatabaseResource>(info.This());
-    if (!r || r->type != QV8SqlDatabaseResource::Rows)
-        V8THROW_REFERENCE("Not a SQLDatabase::Rows object");
-    return v8::Boolean::New(r->query.isForwardOnly());
+    QQmlSqlDatabaseWrapper *r = ctx->thisObject.as<QQmlSqlDatabaseWrapper>();
+    if (!r || r->type != QQmlSqlDatabaseWrapper::Rows)
+        V4THROW_REFERENCE("Not a SQLDatabase::Rows object");
+    return Value::fromBoolean(r->sqlQuery.isForwardOnly());
 }
 
-static void qmlsqldatabase_rows_setForwardOnly(v8::Local<v8::String> /* property */,
-                                               v8::Local<v8::Value> value,
-                                               const v8::AccessorInfo& info)
+static Value qmlsqldatabase_rows_setForwardOnly(SimpleCallContext *ctx)
 {
-    QV8SqlDatabaseResource *r = v8_resource_cast<QV8SqlDatabaseResource>(info.This());
-    if (!r || r->type != QV8SqlDatabaseResource::Rows)
-        V8THROW_REFERENCE_VOID("Not a SQLDatabase::Rows object");
-
-    r->query.setForwardOnly(value->BooleanValue());
+    QQmlSqlDatabaseWrapper *r = ctx->thisObject.as<QQmlSqlDatabaseWrapper>();
+    if (!r || r->type != QQmlSqlDatabaseWrapper::Rows)
+        V4THROW_REFERENCE("Not a SQLDatabase::Rows object");
+    if (ctx->argumentCount < 1)
+        ctx->throwTypeError();
+
+    r->sqlQuery.setForwardOnly(ctx->arguments[0].toBoolean());
+    return Value::undefinedValue();
 }
 
 QQmlSqlDatabaseData::~QQmlSqlDatabaseData()
 {
-    qPersistentDispose(constructor);
-    qPersistentDispose(queryConstructor);
-    qPersistentDispose(rowsConstructor);
 }
 
 static QString qmlsqldatabase_databasesPath(QV8Engine *engine)
@@ -190,103 +191,113 @@ static QString qmlsqldatabase_databaseFile(const QString& connectionName, QV8Eng
     return qmlsqldatabase_databasesPath(engine) + QDir::separator() + connectionName;
 }
 
-static v8::Handle<v8::Value> qmlsqldatabase_rows_index(QV8SqlDatabaseResource *r, uint32_t index)
+static Value qmlsqldatabase_rows_index(QQmlSqlDatabaseWrapper *r, ExecutionEngine *v4, uint32_t index, bool *hasProperty = 0)
 {
-    if (r->query.at() == (int)index || r->query.seek(index)) {
+    QV8Engine *v8 = v4->v8Engine;
 
-        QSqlRecord record = r->query.record();
+    if (r->sqlQuery.at() == (int)index || r->sqlQuery.seek(index)) {
+        QSqlRecord record = r->sqlQuery.record();
         // XXX optimize
-        v8::Local<v8::Object> row = v8::Object::New();
+        Object *row = v4->newObject();
         for (int ii = 0; ii < record.count(); ++ii) {
             QVariant v = record.value(ii);
             if (v.isNull()) {
-                row->Set(r->engine->toString(record.fieldName(ii)), v8::Null());
+                row->put(v4->newIdentifier(record.fieldName(ii)), Value::nullValue());
             } else {
-                row->Set(r->engine->toString(record.fieldName(ii)),
-                         r->engine->fromVariant(v));
+                row->put(v4->newIdentifier(record.fieldName(ii)), v8->fromVariant(v));
             }
         }
-        return row;
+        if (hasProperty)
+            *hasProperty = true;
+        return Value::fromObject(row);
     } else {
-        return v8::Undefined();
+        if (hasProperty)
+            *hasProperty = false;
+        return Value::undefinedValue();
     }
 }
 
-static v8::Handle<v8::Value> qmlsqldatabase_rows_index(uint32_t index, const v8::AccessorInfo& info)
+Value QQmlSqlDatabaseWrapper::getIndexed(Managed *m, uint index, bool *hasProperty)
 {
-    QV8SqlDatabaseResource *r = v8_resource_cast<QV8SqlDatabaseResource>(info.This());
-    if (!r || r->type != QV8SqlDatabaseResource::Rows)
-        V8THROW_REFERENCE("Not a SQLDatabase::Rows object");
+    QQmlSqlDatabaseWrapper *r = m->as<QQmlSqlDatabaseWrapper>();
+    if (!r || r->type != QQmlSqlDatabaseWrapper::Rows)
+        return Object::getIndexed(m, index, hasProperty);
 
-    return qmlsqldatabase_rows_index(r, index);
+    return qmlsqldatabase_rows_index(r, m->engine(), index, hasProperty);
 }
 
-static v8::Handle<v8::Value> qmlsqldatabase_rows_item(const v8::Arguments& args)
+static Value qmlsqldatabase_rows_item(SimpleCallContext *ctx)
 {
-    QV8SqlDatabaseResource *r = v8_resource_cast<QV8SqlDatabaseResource>(args.This());
-    if (!r || r->type != QV8SqlDatabaseResource::Rows)
-        V8THROW_REFERENCE("Not a SQLDatabase::Rows object");
+    QQmlSqlDatabaseWrapper *r = ctx->thisObject.as<QQmlSqlDatabaseWrapper>();
+    if (!r || r->type != QQmlSqlDatabaseWrapper::Rows)
+        V4THROW_REFERENCE("Not a SQLDatabase::Rows object");
 
-    return qmlsqldatabase_rows_index(r, args.Length()?args[0]->Uint32Value():0);
+    return qmlsqldatabase_rows_index(r, ctx->engine, ctx->argumentCount ? ctx->arguments[0].toUInt32() : 0);
 }
 
-static v8::Handle<v8::Value> qmlsqldatabase_executeSql(const v8::Arguments& args)
+static Value qmlsqldatabase_executeSql(SimpleCallContext *ctx)
 {
-    QV8SqlDatabaseResource *r = v8_resource_cast<QV8SqlDatabaseResource>(args.This());
-    if (!r || r->type != QV8SqlDatabaseResource::Query)
-        V8THROW_REFERENCE("Not a SQLDatabase::Query object");
+    QQmlSqlDatabaseWrapper *r = ctx->thisObject.as<QQmlSqlDatabaseWrapper>();
+    if (!r || r->type != QQmlSqlDatabaseWrapper::Query)
+        V4THROW_REFERENCE("Not a SQLDatabase::Query object");
 
-    QV8Engine *engine = r->engine;
+    QV8Engine *engine = ctx->engine->v8Engine;
 
     if (!r->inTransaction)
-        V8THROW_SQL(SQLEXCEPTION_DATABASE_ERR,QQmlEngine::tr("executeSql called outside transaction()"));
+        V4THROW_SQL(SQLEXCEPTION_DATABASE_ERR,QQmlEngine::tr("executeSql called outside transaction()"));
 
     QSqlDatabase db = r->database;
 
-    QString sql = engine->toString(args[0]);
+    QString sql = ctx->argument(0).toQString();
 
     if (r->readonly && !sql.startsWith(QLatin1String("SELECT"),Qt::CaseInsensitive)) {
-        V8THROW_SQL(SQLEXCEPTION_SYNTAX_ERR, QQmlEngine::tr("Read-only Transaction"));
+        V4THROW_SQL(SQLEXCEPTION_SYNTAX_ERR, QQmlEngine::tr("Read-only Transaction"));
     }
 
     QSqlQuery query(db);
     bool err = false;
 
-    v8::Handle<v8::Value> result = v8::Undefined();
+    Value result = Value::undefinedValue();
 
     if (query.prepare(sql)) {
-        if (args.Length() > 1) {
-            v8::Local<v8::Value> values = args[1];
-            if (values->IsArray()) {
-                v8::Local<v8::Array> array = v8::Local<v8::Array>::Cast(values);
-                uint32_t size = array->Length();
+        if (ctx->argumentCount > 1) {
+            Value values = ctx->arguments[1];
+            if (ArrayObject *array = values.asArrayObject()) {
+                uint32_t size = array->arrayLength();
                 for (uint32_t ii = 0; ii < size; ++ii)
-                    query.bindValue(ii, engine->toVariant(array->Get(ii), -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(engine->toString(names->Get(ii)),
-                                    engine->toVariant(object->Get(names->Get(ii)), -1));
+                    query.bindValue(ii, engine->toVariant(array->getIndexed(ii), -1));
+            } else if (Object *object = values.asObject()) {
+                ObjectIterator it(object, ObjectIterator::WithProtoChain|ObjectIterator::EnumerableOnly);
+                while (1) {
+                    Value value;
+                    Value key = it.nextPropertyName(&value);
+                    if (key.isNull())
+                        break;
+                    QVariant v = engine->toVariant(value, -1);
+                    if (key.isString()) {
+                        query.bindValue(key.stringValue()->toQString(), v);
+                    } else {
+                        assert(key.isInteger());
+                        query.bindValue(key.integerValue(), v);
+                    }
+                }
             } else {
                 query.bindValue(0, engine->toVariant(values, -1));
             }
         }
         if (query.exec()) {
-            v8::Handle<v8::Object> rows = databaseData(engine)->rowsConstructor->NewInstance();
-            QV8SqlDatabaseResource *r = new QV8SqlDatabaseResource(engine);
-            r->type = QV8SqlDatabaseResource::Rows;
-            r->database = db;
-            r->query = query;
-            rows->SetExternalResource(r);
-
-            v8::Local<v8::Object> resultObject = v8::Object::New();
-            result = resultObject;
+            QQmlSqlDatabaseWrapper *rows = new (ctx->engine->memoryManager) QQmlSqlDatabaseWrapper(engine);
+            rows->prototype = databaseData(engine)->rowsProto.value().asObject();
+            rows->type = QQmlSqlDatabaseWrapper::Rows;
+            rows->database = db;
+            rows->sqlQuery = query;
+
+            Object *resultObject = ctx->engine->newObject();
+            result = Value::fromObject(resultObject);
             // XXX optimize
-            resultObject->Set(v8::String::New("rowsAffected"), v8::Integer::New(query.numRowsAffected()));
-            resultObject->Set(v8::String::New("insertId"), engine->toString(query.lastInsertId().toString()));
-            resultObject->Set(v8::String::New("rows"), rows);
+            resultObject->put(ctx->engine->newIdentifier("rowsAffected"), Value::fromInt32(query.numRowsAffected()));
+            resultObject->put(ctx->engine->newIdentifier("insertId"), engine->toString(query.lastInsertId().toString()));
+            resultObject->put(ctx->engine->newIdentifier("rows"), Value::fromObject(rows));
         } else {
             err = true;
         }
@@ -294,153 +305,152 @@ static v8::Handle<v8::Value> qmlsqldatabase_executeSql(const v8::Arguments& args
         err = true;
     }
     if (err)
-        V8THROW_SQL(SQLEXCEPTION_DATABASE_ERR,query.lastError().text());
+        V4THROW_SQL(SQLEXCEPTION_DATABASE_ERR,query.lastError().text());
 
     return result;
 }
 
-static v8::Handle<v8::Value> qmlsqldatabase_changeVersion(const v8::Arguments& args)
+static Value qmlsqldatabase_changeVersion(SimpleCallContext *ctx)
 {
-    if (args.Length() < 2)
-        return v8::Undefined();
+    if (ctx->argumentCount < 2)
+        return Value::undefinedValue();
 
-    QV8SqlDatabaseResource *r = v8_resource_cast<QV8SqlDatabaseResource>(args.This());
-    if (!r || r->type != QV8SqlDatabaseResource::Database)
-        V8THROW_REFERENCE("Not a SQLDatabase object");
+    QQmlSqlDatabaseWrapper *r = ctx->thisObject.as<QQmlSqlDatabaseWrapper>();
+    if (!r || r->type != QQmlSqlDatabaseWrapper::Database)
+        V4THROW_REFERENCE("Not a SQLDatabase object");
 
-    QV8Engine *engine = r->engine;
+    QV8Engine *engine = ctx->engine->v8Engine;
 
     QSqlDatabase db = r->database;
-    QString from_version = engine->toString(args[0]);
-    QString to_version = engine->toString(args[1]);
-    v8::Handle<v8::Value> callback = args[2];
+    QString from_version = ctx->arguments[0].toQString();
+    QString to_version = ctx->arguments[1].toQString();
+    Value callback = ctx->argument(2);
 
     if (from_version != r->version)
-        V8THROW_SQL(SQLEXCEPTION_VERSION_ERR, QQmlEngine::tr("Version mismatch: expected %1, found %2").arg(from_version).arg(r->version));
+        V4THROW_SQL(SQLEXCEPTION_VERSION_ERR, QQmlEngine::tr("Version mismatch: expected %1, found %2").arg(from_version).arg(r->version));
 
-    v8::Local<v8::Object> instance = databaseData(engine)->queryConstructor->NewInstance();
-    QV8SqlDatabaseResource *r2 = new QV8SqlDatabaseResource(engine);
-    r2->type = QV8SqlDatabaseResource::Query;
-    r2->database = db;
-    r2->version = r->version;
-    r2->inTransaction = true;
-    instance->SetExternalResource(r2);
+    QQmlSqlDatabaseWrapper *w = new (ctx->engine->memoryManager) QQmlSqlDatabaseWrapper(engine);
+    w->prototype = databaseData(engine)->queryProto.value().asObject();
+    w->type = QQmlSqlDatabaseWrapper::Query;
+    w->database = db;
+    w->version = r->version;
+    w->inTransaction = true;
 
     bool ok = true;
-    if (callback->IsFunction()) {
+    if (FunctionObject *f = callback.asFunctionObject()) {
         ok = false;
         db.transaction();
 
-        v8::TryCatch tc;
-        v8::Handle<v8::Value> callbackArgs[] = { instance };
-        v8::Handle<v8::Function>::Cast(callback)->Call(engine->global(), 1, callbackArgs);
-
-        if (tc.HasCaught()) {
+        Value callbackArgs[] = { Value::fromObject(w) };
+        try {
+            f->call(engine->global(), callbackArgs, 1);
+        } catch (Exception &) {
             db.rollback();
-            tc.ReThrow();
-            return v8::Handle<v8::Value>();
-        } else if (!db.commit()) {
+            throw;
+        }
+        if (!db.commit()) {
             db.rollback();
-            V8THROW_SQL(SQLEXCEPTION_UNKNOWN_ERR,QQmlEngine::tr("SQL transaction failed"));
+            V4THROW_SQL(SQLEXCEPTION_UNKNOWN_ERR,QQmlEngine::tr("SQL transaction failed"));
         } else {
             ok = true;
         }
     }
 
-    r2->inTransaction = false;
+    w->inTransaction = false;
 
     if (ok) {
-        r2->version = to_version;
+        w->version = to_version;
 #ifndef QT_NO_SETTINGS
         QSettings ini(qmlsqldatabase_databaseFile(db.connectionName(),engine) + QLatin1String(".ini"), QSettings::IniFormat);
         ini.setValue(QLatin1String("Version"), to_version);
 #endif
     }
 
-    return v8::Undefined();
+    return Value::undefinedValue();
 }
 
-static v8::Handle<v8::Value> qmlsqldatabase_transaction_shared(const v8::Arguments& args, bool readOnly)
+static Value qmlsqldatabase_transaction_shared(SimpleCallContext *ctx, bool readOnly)
 {
-    QV8SqlDatabaseResource *r = v8_resource_cast<QV8SqlDatabaseResource>(args.This());
-    if (!r || r->type != QV8SqlDatabaseResource::Database)
-        V8THROW_REFERENCE("Not a SQLDatabase object");
+    QQmlSqlDatabaseWrapper *r = ctx->thisObject.as<QQmlSqlDatabaseWrapper>();
+    if (!r || r->type != QQmlSqlDatabaseWrapper::Database)
+        V4THROW_REFERENCE("Not a SQLDatabase object");
 
-    QV8Engine *engine = r->engine;
+    QV8Engine *engine = ctx->engine->v8Engine;
 
-    if (args.Length() == 0 || !args[0]->IsFunction())
-        V8THROW_SQL(SQLEXCEPTION_UNKNOWN_ERR,QQmlEngine::tr("transaction: missing callback"));
+    FunctionObject *callback = ctx->argumentCount ? ctx->arguments[0].asFunctionObject() : 0;
+    if (!callback)
+        V4THROW_SQL(SQLEXCEPTION_UNKNOWN_ERR, QQmlEngine::tr("transaction: missing callback"));
 
     QSqlDatabase db = r->database;
-    v8::Handle<v8::Function> callback = v8::Handle<v8::Function>::Cast(args[0]);
 
-    v8::Local<v8::Object> instance = databaseData(engine)->queryConstructor->NewInstance();
-    QV8SqlDatabaseResource *q = new QV8SqlDatabaseResource(engine);
-    q->type = QV8SqlDatabaseResource::Query;
-    q->database = db;
-    q->readonly = readOnly;
-    q->inTransaction = true;
-    instance->SetExternalResource(q);
+    QQmlSqlDatabaseWrapper *w = new (ctx->engine->memoryManager) QQmlSqlDatabaseWrapper(engine);
+    w->prototype = databaseData(engine)->queryProto.value().asObject();
+    w->type = QQmlSqlDatabaseWrapper::Query;
+    w->database = db;
+    w->version = r->version;
+    w->readonly = readOnly;
+    w->inTransaction = true;
 
     db.transaction();
-    v8::TryCatch tc;
-    v8::Handle<v8::Value> callbackArgs[] = { instance };
-    callback->Call(engine->global(), 1, callbackArgs);
-
-    q->inTransaction = false;
-
-    if (tc.HasCaught()) {
-        db.rollback();
-        tc.ReThrow();
-        return v8::Handle<v8::Value>();
-    } else if (!db.commit()) {
-        db.rollback();
+    if (callback) {
+        Value callbackArgs[] = { Value::fromObject(w) };
+        try {
+            callback->call(engine->global(), callbackArgs, 1);
+        } catch (Exception &) {
+            w->inTransaction = false;
+            db.rollback();
+            throw;
+        }
+
+        w->inTransaction = false;
+
+        if (!db.commit())
+            db.rollback();
     }
 
-    return v8::Undefined();
+    return Value::undefinedValue();
 }
 
-static v8::Handle<v8::Value> qmlsqldatabase_transaction(const v8::Arguments& args)
+static Value qmlsqldatabase_transaction(SimpleCallContext *ctx)
 {
-    return qmlsqldatabase_transaction_shared(args, false);
+    return qmlsqldatabase_transaction_shared(ctx, false);
 }
 
-static v8::Handle<v8::Value> qmlsqldatabase_read_transaction(const v8::Arguments& args)
+static Value qmlsqldatabase_read_transaction(SimpleCallContext *ctx)
 {
-    return qmlsqldatabase_transaction_shared(args, true);
+    return qmlsqldatabase_transaction_shared(ctx, true);
 }
 
 QQmlSqlDatabaseData::QQmlSqlDatabaseData(QV8Engine *engine)
 {
+    ExecutionEngine *v4 = QV8Engine::getV4(engine);
     {
-    v8::Local<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
-    ft->InstanceTemplate()->SetHasExternalResource(true);
-    ft->PrototypeTemplate()->Set(v8::String::New("transaction"),
-                                 V8FUNCTION(qmlsqldatabase_transaction, engine));
-    ft->PrototypeTemplate()->Set(v8::String::New("readTransaction"),
-                                 V8FUNCTION(qmlsqldatabase_read_transaction, engine));
-    ft->PrototypeTemplate()->SetAccessor(v8::String::New("version"), qmlsqldatabase_version);
-    ft->PrototypeTemplate()->Set(v8::String::New("changeVersion"),
-                                 V8FUNCTION(qmlsqldatabase_changeVersion, engine));
-    constructor = qPersistentNew<v8::Function>(ft->GetFunction());
+        Object *proto = v4->newObject();
+        proto->defineDefaultProperty(v4, QStringLiteral("transaction"), qmlsqldatabase_transaction);
+        proto->defineDefaultProperty(v4, QStringLiteral("readTransaction"), qmlsqldatabase_read_transaction);
+        Property *p = proto->insertMember(v4->newString(QStringLiteral("version")),
+                                          Attr_Accessor|Attr_NotConfigurable|Attr_NotEnumerable);
+        p->setGetter(v4->newBuiltinFunction(v4->rootContext, v4->newString(QStringLiteral("version")), qmlsqldatabase_version));
+        proto->defineDefaultProperty(v4, QStringLiteral("changeVersion"), qmlsqldatabase_changeVersion);
+        databaseProto = Value::fromObject(proto);
     }
 
     {
-    v8::Local<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
-    ft->InstanceTemplate()->SetHasExternalResource(true);
-    ft->PrototypeTemplate()->Set(v8::String::New("executeSql"),
-                                 V8FUNCTION(qmlsqldatabase_executeSql, engine));
-    queryConstructor = qPersistentNew<v8::Function>(ft->GetFunction());
+        Object *proto = v4->newObject();
+        proto->defineDefaultProperty(v4, QStringLiteral("executeSql"), qmlsqldatabase_executeSql);
+        queryProto = Value::fromObject(proto);
     }
     {
-    v8::Local<v8::FunctionTemplate> ft = v8::FunctionTemplate::New();
-    ft->InstanceTemplate()->SetHasExternalResource(true);
-    ft->PrototypeTemplate()->Set(v8::String::New("item"), V8FUNCTION(qmlsqldatabase_rows_item, engine));
-    ft->PrototypeTemplate()->SetAccessor(v8::String::New("length"), qmlsqldatabase_rows_length);
-    ft->InstanceTemplate()->SetAccessor(v8::String::New("forwardOnly"), qmlsqldatabase_rows_forwardOnly,
-                                        qmlsqldatabase_rows_setForwardOnly);
-    ft->InstanceTemplate()->SetIndexedPropertyHandler(qmlsqldatabase_rows_index);
-    rowsConstructor = qPersistentNew<v8::Function>(ft->GetFunction());
+        Object *proto = v4->newObject();
+        proto->defineDefaultProperty(v4, QStringLiteral("item"), qmlsqldatabase_rows_item);
+        Property *p = proto->insertMember(v4->newString(QStringLiteral("length")),
+                                          Attr_Accessor|Attr_NotConfigurable|Attr_NotEnumerable);
+        p->setGetter(v4->newBuiltinFunction(v4->rootContext, v4->newString(QStringLiteral("length")), qmlsqldatabase_rows_length));
+        p = proto->insertMember(v4->newString(QStringLiteral("forwardOnly")),
+                                Attr_Accessor|Attr_NotConfigurable|Attr_NotEnumerable);
+        p->setGetter(v4->newBuiltinFunction(v4->rootContext, v4->newString(QStringLiteral("forwardOnly")), qmlsqldatabase_rows_forwardOnly));
+        p->setSetter(v4->newBuiltinFunction(v4->rootContext, v4->newString(QStringLiteral("setForwardOnly")), qmlsqldatabase_rows_setForwardOnly));
+        rowsProto = Value::fromObject(proto);
     }
 }
 
@@ -597,25 +607,26 @@ public:
     ~QQuickLocalStorage() {
     }
 
-   Q_INVOKABLE void openDatabaseSync(QQmlV8Function* args);
+   Q_INVOKABLE void openDatabaseSync(QQmlV4Function* args);
 };
 
-void QQuickLocalStorage::openDatabaseSync(QQmlV8Function *args)
+void QQuickLocalStorage::openDatabaseSync(QQmlV4Function *args)
 {
 #ifndef QT_NO_SETTINGS
     QV8Engine *engine = args->engine();
+    ExecutionContext *ctx = QV8Engine::getV4(engine)->current;
     if (engine->engine()->offlineStoragePath().isEmpty())
-        V8THROW_SQL_VOID(SQLEXCEPTION_DATABASE_ERR, QQmlEngine::tr("SQL: can't create database, offline storage is disabled."));
+        V4THROW_SQL(SQLEXCEPTION_DATABASE_ERR, QQmlEngine::tr("SQL: can't create database, offline storage is disabled."));
 
     qmlsqldatabase_initDatabasesPath(engine);
 
     QSqlDatabase database;
 
-    QString dbname = engine->toString((*args)[0]);
-    QString dbversion = engine->toString((*args)[1]);
-    QString dbdescription = engine->toString((*args)[2]);
-    int dbestimatedsize = (*args)[3]->Int32Value();
-    v8::Handle<v8::Value> dbcreationCallback = (*args)[4];
+    QString dbname = (*args)[0].toQString();
+    QString dbversion = (*args)[1].toQString();
+    QString dbdescription = (*args)[2].toQString();
+    int dbestimatedsize = (*args)[3].toInt32();
+    FunctionObject *dbcreationCallback = (*args)[4].asFunctionObject();
 
     QCryptographicHash md5(QCryptographicHash::Md5);
     md5.addData(dbname.toUtf8());
@@ -632,13 +643,13 @@ void QQuickLocalStorage::openDatabaseSync(QQmlV8Function *args)
             database = QSqlDatabase::database(dbid);
             version = ini.value(QLatin1String("Version")).toString();
             if (version != dbversion && !dbversion.isEmpty() && !version.isEmpty())
-                V8THROW_SQL_VOID(SQLEXCEPTION_VERSION_ERR, QQmlEngine::tr("SQL: database version mismatch"));
+                V4THROW_SQL(SQLEXCEPTION_VERSION_ERR, QQmlEngine::tr("SQL: database version mismatch"));
         } else {
             created = !QFile::exists(basename+QLatin1String(".sqlite"));
             database = QSqlDatabase::addDatabase(QLatin1String("QSQLITE"), dbid);
             if (created) {
                 ini.setValue(QLatin1String("Name"), dbname);
-                if (dbcreationCallback->IsFunction())
+                if (dbcreationCallback)
                     version = QString();
                 ini.setValue(QLatin1String("Version"), version);
                 ini.setValue(QLatin1String("Description"), dbdescription);
@@ -647,7 +658,7 @@ void QQuickLocalStorage::openDatabaseSync(QQmlV8Function *args)
             } else {
                 if (!dbversion.isEmpty() && ini.value(QLatin1String("Version")) != dbversion) {
                     // Incompatible
-                    V8THROW_SQL_VOID(SQLEXCEPTION_VERSION_ERR,QQmlEngine::tr("SQL: database version mismatch"));
+                    V4THROW_SQL(SQLEXCEPTION_VERSION_ERR,QQmlEngine::tr("SQL: database version mismatch"));
                 }
                 version = ini.value(QLatin1String("Version")).toString();
             }
@@ -657,25 +668,17 @@ void QQuickLocalStorage::openDatabaseSync(QQmlV8Function *args)
             database.open();
     }
 
-    v8::Local<v8::Object> instance = databaseData(engine)->constructor->NewInstance();
-
-    QV8SqlDatabaseResource *r = new QV8SqlDatabaseResource(engine);
-    r->database = database;
-    r->version = version;
-    instance->SetExternalResource(r);
-
-    if (created && dbcreationCallback->IsFunction()) {
-        v8::TryCatch tc;
-        v8::Handle<v8::Function> callback = v8::Handle<v8::Function>::Cast(dbcreationCallback);
-        v8::Handle<v8::Value> args[] = { instance };
-        callback->Call(engine->global(), 1, args);
-        if (tc.HasCaught()) {
-            tc.ReThrow();
-            return;
-        }
+    QQmlSqlDatabaseWrapper *db = new (ctx->engine->memoryManager) QQmlSqlDatabaseWrapper(engine);
+    db->prototype = databaseData(engine)->databaseProto.value().asObject();
+    db->database = database;
+    db->version = version;
+
+    if (created && dbcreationCallback) {
+        Value args[] = { Value::fromObject(db) };
+        dbcreationCallback->call(engine->global(), args, 1);
     }
 
-    args->returnValue(instance);
+    args->setReturnValue(Value::fromObject(db));
 #endif // QT_NO_SETTINGS
 }
 
diff --git a/src/imports/localstorage/plugins.qmltypes b/src/imports/localstorage/plugins.qmltypes
index ec60a142d4..bcd516c25e 100644
--- a/src/imports/localstorage/plugins.qmltypes
+++ b/src/imports/localstorage/plugins.qmltypes
@@ -13,7 +13,7 @@ Module {
         exportMetaObjectRevisions: [0]
         Method {
             name: "openDatabaseSync"
-            Parameter { name: "args"; type: "QQmlV8Function"; isPointer: true }
+            Parameter { name: "args"; type: "QQmlV4Function"; isPointer: true }
         }
     }
 }
diff --git a/src/imports/particles/plugins.qmltypes b/src/imports/particles/plugins.qmltypes
index ee948ad7b0..495c072a41 100644
--- a/src/imports/particles/plugins.qmltypes
+++ b/src/imports/particles/plugins.qmltypes
@@ -163,7 +163,7 @@ Module {
         Property { name: "acceleration"; type: "QQuickDirection"; isPointer: true }
         Signal {
             name: "affectParticles"
-            Parameter { name: "particles"; type: "QQmlV8Handle" }
+            Parameter { name: "particles"; type: "QQmlV4Handle" }
             Parameter { name: "dt"; type: "double" }
         }
         Signal {
@@ -664,7 +664,7 @@ Module {
         Property { name: "velocityFromMovement"; type: "double" }
         Signal {
             name: "emitParticles"
-            Parameter { name: "particles"; type: "QQmlV8Handle" }
+            Parameter { name: "particles"; type: "QQmlV4Handle" }
         }
         Signal {
             name: "particlesPerSecondChanged"
@@ -1078,8 +1078,8 @@ Module {
         Property { name: "emitWidth"; type: "double" }
         Signal {
             name: "emitFollowParticles"
-            Parameter { name: "particles"; type: "QQmlV8Handle" }
-            Parameter { name: "followed"; type: "QQmlV8Handle" }
+            Parameter { name: "particles"; type: "QQmlV4Handle" }
+            Parameter { name: "followed"; type: "QQmlV4Handle" }
         }
         Signal {
             name: "particlesPerParticlePerSecondChanged"
diff --git a/src/imports/qtquick2/plugins.qmltypes b/src/imports/qtquick2/plugins.qmltypes
index cc619dc4ff..02c7d61536 100644
--- a/src/imports/qtquick2/plugins.qmltypes
+++ b/src/imports/qtquick2/plugins.qmltypes
@@ -1029,7 +1029,7 @@ Module {
         }
         Property { name: "available"; type: "bool"; isReadonly: true }
         Property { name: "contextType"; type: "string" }
-        Property { name: "context"; type: "QQmlV8Handle"; isReadonly: true }
+        Property { name: "context"; type: "QQmlV4Handle"; isReadonly: true }
         Property { name: "canvasSize"; type: "QSizeF" }
         Property { name: "tileSize"; type: "QSize" }
         Property { name: "canvasWindow"; type: "QRectF" }
@@ -3929,7 +3929,7 @@ Module {
         Property { name: "source"; type: "QUrl" }
         Signal {
             name: "message"
-            Parameter { name: "messageObject"; type: "QQmlV8Handle" }
+            Parameter { name: "messageObject"; type: "QQmlV4Handle" }
         }
         Method {
             name: "sendMessage"
diff --git a/src/imports/testlib/main.cpp b/src/imports/testlib/main.cpp
index 2ddb9deddc..81dcaa2fc3 100644
--- a/src/imports/testlib/main.cpp
+++ b/src/imports/testlib/main.cpp
@@ -82,7 +82,7 @@ Q_SIGNALS:
 
 public Q_SLOTS:
 
-    QQmlV8Handle typeName(const QVariant& v) const
+    QQmlV4Handle typeName(const QVariant& v) const
     {
         QString name(v.typeName());
         if (v.canConvert<QObject*>()) {
@@ -97,31 +97,33 @@ public Q_SLOTS:
             }
         }
 
-        return QQmlV8Handle::fromHandle(v8::String::New(name.toUtf8()));
+        QQmlEngine *engine = qmlEngine(this);
+        QV4::ExecutionEngine *v4 = QV8Engine::getV4(engine->handle());
+        return QQmlV4Handle(QV4::Value::fromString(v4->newString(name)));
     }
 
     bool compare(const QVariant& act, const QVariant& exp) const {
         return act == exp;
     }
 
-    QQmlV8Handle callerFile(int frameIndex = 0) const
+    QQmlV4Handle callerFile(int frameIndex = 0) const
     {
-        v8::Local<v8::StackTrace> stacks = v8::StackTrace::CurrentStackTrace(10, v8::StackTrace::kDetailed);
-        int count = stacks->GetFrameCount();
-        if (count >= frameIndex + 1) {
-            v8::Local<v8::StackFrame> frame = stacks->GetFrame(frameIndex + 1);
-            return QQmlV8Handle::fromHandle(frame->GetScriptNameOrSourceURL());
-        }
-        return QQmlV8Handle();
+        QQmlEngine *engine = qmlEngine(this);
+        QV4::ExecutionEngine *v4 = QV8Engine::getV4(engine->handle());
+
+        QVector<QV4::ExecutionEngine::StackFrame> stack = v4->stackTrace(frameIndex + 1);
+        if (stack.size() > frameIndex)
+            return QQmlV4Handle(QV4::Value::fromString(v4->newString(stack.at(frameIndex).source)));
+        return QQmlV4Handle();
     }
     int callerLine(int frameIndex = 0) const
     {
-        v8::Local<v8::StackTrace> stacks = v8::StackTrace::CurrentStackTrace(10, v8::StackTrace::kDetailed);
-        int count = stacks->GetFrameCount();
-        if (count >= frameIndex + 1) {
-            v8::Local<v8::StackFrame> frame = stacks->GetFrame(frameIndex + 1);
-            return frame->GetLineNumber();
-        }
+        QQmlEngine *engine = qmlEngine(this);
+        QV4::ExecutionEngine *v4 = QV8Engine::getV4(engine->handle());
+
+        QVector<QV4::ExecutionEngine::StackFrame> stack = v4->stackTrace(frameIndex + 1);
+        if (stack.size() > frameIndex)
+            return stack.at(frameIndex).line;
         return -1;
     }
 };
diff --git a/src/imports/testlib/plugins.qmltypes b/src/imports/testlib/plugins.qmltypes
index 7530e490f3..2865812eb2 100644
--- a/src/imports/testlib/plugins.qmltypes
+++ b/src/imports/testlib/plugins.qmltypes
@@ -259,7 +259,7 @@ Module {
         Property { name: "dragThreshold"; type: "int"; isReadonly: true }
         Method {
             name: "typeName"
-            type: "QQmlV8Handle"
+            type: "QQmlV4Handle"
             Parameter { name: "v"; type: "QVariant" }
         }
         Method {
@@ -270,10 +270,10 @@ Module {
         }
         Method {
             name: "callerFile"
-            type: "QQmlV8Handle"
+            type: "QQmlV4Handle"
             Parameter { name: "frameIndex"; type: "int" }
         }
-        Method { name: "callerFile"; type: "QQmlV8Handle" }
+        Method { name: "callerFile"; type: "QQmlV4Handle" }
         Method {
             name: "callerLine"
             type: "int"
diff --git a/src/imports/testlib/testlib.pro b/src/imports/testlib/testlib.pro
index 56f0ea4806..6e8a6aee72 100644
--- a/src/imports/testlib/testlib.pro
+++ b/src/imports/testlib/testlib.pro
@@ -3,7 +3,7 @@ TARGET  = qmltestplugin
 TARGETPATH = QtTest
 IMPORT_VERSION = 1.0
 
-QT += qml quick qmltest qmltest-private v8-private qml-private core-private testlib
+QT += qml quick qmltest qmltest-private  qml-private core-private testlib
 
 SOURCES += main.cpp
 
diff --git a/src/imports/widgets/widgets.pro b/src/imports/widgets/widgets.pro
index c444674a75..7e6a04161a 100644
--- a/src/imports/widgets/widgets.pro
+++ b/src/imports/widgets/widgets.pro
@@ -18,6 +18,6 @@ HEADERS += \
     ../dialogs/qquickabstractcolordialog_p.h \
     ../dialogs/qquickabstractdialog_p.h
 
-QT += quick-private gui-private core-private qml-private v8-private widgets
+QT += quick-private gui-private core-private qml-private  widgets
 
 load(qml_plugin)
diff --git a/src/imports/xmllistmodel/plugins.qmltypes b/src/imports/xmllistmodel/plugins.qmltypes
index 2a431ebf81..d951d07719 100644
--- a/src/imports/xmllistmodel/plugins.qmltypes
+++ b/src/imports/xmllistmodel/plugins.qmltypes
@@ -40,7 +40,7 @@ Module {
         Method { name: "reload" }
         Method {
             name: "get"
-            type: "QQmlV8Handle"
+            type: "QQmlV4Handle"
             Parameter { name: "index"; type: "int" }
         }
         Method { name: "errorString"; type: "string" }
diff --git a/src/imports/xmllistmodel/qqmlxmllistmodel.cpp b/src/imports/xmllistmodel/qqmlxmllistmodel.cpp
index 7cc4e64522..c12bfee924 100644
--- a/src/imports/xmllistmodel/qqmlxmllistmodel.cpp
+++ b/src/imports/xmllistmodel/qqmlxmllistmodel.cpp
@@ -43,6 +43,10 @@
 
 #include <qqmlcontext.h>
 #include <private/qqmlengine_p.h>
+#include <private/qv8engine_p.h>
+#include <private/qv4value_p.h>
+#include <private/qv4engine_p.h>
+#include <private/qv4object_p.h>
 
 #include <QDebug>
 #include <QStringList>
@@ -63,6 +67,7 @@ Q_DECLARE_METATYPE(QQuickXmlQueryResult)
 
 QT_BEGIN_NAMESPACE
 
+using namespace QV4;
 
 typedef QPair<int, int> QQuickXmlListRange;
 
@@ -907,22 +912,24 @@ void QQuickXmlListModel::setNamespaceDeclarations(const QString &declarations)
     var title = model.get(0).title;
     \endjs
 */
-QQmlV8Handle QQuickXmlListModel::get(int index) const
+QQmlV4Handle QQuickXmlListModel::get(int index) const
 {
     // Must be called with a context and handle scope
     Q_D(const QQuickXmlListModel);
 
     if (index < 0 || index >= count())
-        return QQmlV8Handle::fromHandle(v8::Undefined());
+        return QQmlV4Handle(Value::undefinedValue());
 
     QQmlEngine *engine = qmlContext(this)->engine();
     QV8Engine *v8engine = QQmlEnginePrivate::getV8Engine(engine);
-    v8::Local<v8::Object> rv = v8::Object::New();
-    for (int ii = 0; ii < d->roleObjects.count(); ++ii)
-        rv->Set(v8engine->toString(d->roleObjects[ii]->name()),
-                v8engine->fromVariant(d->data.value(ii).value(index)));
+    ExecutionEngine *v4engine = QV8Engine::getV4(v8engine);
+    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));
+    }
 
-    return QQmlV8Handle::fromHandle(rv);
+    return QQmlV4Handle(Value::fromObject(o));
 }
 
 /*!
diff --git a/src/imports/xmllistmodel/qqmlxmllistmodel_p.h b/src/imports/xmllistmodel/qqmlxmllistmodel_p.h
index 0a11cc6e28..ca4b7cf811 100644
--- a/src/imports/xmllistmodel/qqmlxmllistmodel_p.h
+++ b/src/imports/xmllistmodel/qqmlxmllistmodel_p.h
@@ -107,7 +107,7 @@ public:
     QString namespaceDeclarations() const;
     void setNamespaceDeclarations(const QString&);
 
-    Q_INVOKABLE QQmlV8Handle get(int index) const;
+    Q_INVOKABLE QQmlV4Handle get(int index) const;
 
     enum Status { Null, Ready, Loading, Error };
     Status status() const;
diff --git a/src/imports/xmllistmodel/xmllistmodel.pro b/src/imports/xmllistmodel/xmllistmodel.pro
index c2cb4bbd89..2308f26d1b 100644
--- a/src/imports/xmllistmodel/xmllistmodel.pro
+++ b/src/imports/xmllistmodel/xmllistmodel.pro
@@ -3,7 +3,7 @@ TARGET  = qmlxmllistmodelplugin
 TARGETPATH = QtQuick/XmlListModel
 IMPORT_VERSION = 2.0
 
-QT = network xmlpatterns qml-private v8-private core-private
+QT = network xmlpatterns qml-private  core-private
 
 SOURCES += qqmlxmllistmodel.cpp plugin.cpp
 HEADERS += qqmlxmllistmodel_p.h