More steps towards eliminating the v8 layer

* Changed the return type of the InvocationCallback from a v8 handle to a QV4::Value
* Removed v4 auto tests and fixed build of other tests

Change-Id: Ic927b925923ca8785170689a5c260969fd1cb794
Reviewed-by: Lars Knoll <lars.knoll@digia.com>

26 files changed, 550 insertions, 513 deletions

diff --git a/src/imports/localstorage/plugin.cpp b/src/imports/localstorage/plugin.cpp
index 7e4b805ad6..498e541a25 100644
--- a/src/imports/localstorage/plugin.cpp
+++ b/src/imports/localstorage/plugin.cpp
@@ -55,7 +55,7 @@
 #include <QtCore/qsettings.h>
 #include <QtCore/qdir.h>
 #include <private/qv4sqlerrors_p.h>
-
+#include <private/qv4engine_p.h>
 
 #define V8THROW_SQL(error, desc) \
 { \
@@ -65,6 +65,14 @@
     return v8::Handle<v8::Value>(); \
 }
 
+#define V4THROW_SQL(error, desc) { \
+    QV4::ExecutionContext *ctx = v8::Isolate::GetEngine()->current; \
+    QV4::Value v = QV4::Value::fromString(ctx, desc); \
+    QV4::Object *ex = ctx->engine->newErrorObject(v); \
+    ex->put(ctx, ctx->engine->newIdentifier(QStringLiteral("code")), QV4::Value::fromInt32(error)); \
+    ctx->throwError(QV4::Value::fromObject(ex)); \
+}
+
 #define V8THROW_SQL_VOID(error, desc) \
 { \
     v8::Handle<v8::Value> v = v8::Exception::Error(engine->toString(desc)); \
@@ -78,6 +86,9 @@
     return v8::Handle<v8::Value>(); \
 }
 
+#define V4THROW_REFERENCE(string) \
+    v8::Isolate::GetEngine()->current->throwError(QV4::Value::fromObject(v8::Isolate::GetEngine()->newReferenceErrorObject(QStringLiteral(string))))
+
 #define V8THROW_REFERENCE_VOID(string) { \
     v8::ThrowException(v8::Exception::ReferenceError(v8::String::New(string))); \
     return; \
@@ -190,23 +201,23 @@ 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 QV4::Value qmlsqldatabase_rows_index(QV8SqlDatabaseResource *r, uint32_t index)
 {
     if (r->query.at() == (int)index || r->query.seek(index)) {
 
         QSqlRecord record = r->query.record();
         // XXX optimize
-        v8::Handle<v8::Object> row = v8::Object::New();
+        QV4::Object *row = QV8Engine::getV4(r->engine)->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)), QV4::Value::nullValue());
+                row->put(QV8Engine::getV4(r->engine)->current, QV8Engine::getV4(r->engine)->newIdentifier(record.fieldName(ii)), QV4::Value::nullValue());
             } else {
-                row->Set(r->engine->toString(record.fieldName(ii)),
+                row->put(QV8Engine::getV4(r->engine)->current, QV8Engine::getV4(r->engine)->newIdentifier(record.fieldName(ii)),
                          r->engine->fromVariant(v));
             }
         }
-        return row;
+        return QV4::Value::fromObject(row);
     } else {
         return QV4::Value::undefinedValue();
     }
@@ -221,38 +232,38 @@ static v8::Handle<v8::Value> qmlsqldatabase_rows_index(uint32_t index, const v8:
     return qmlsqldatabase_rows_index(r, index);
 }
 
-static v8::Handle<v8::Value> qmlsqldatabase_rows_item(const v8::Arguments& args)
+static QV4::Value qmlsqldatabase_rows_item(const v8::Arguments& args)
 {
     QV8SqlDatabaseResource *r = v8_resource_cast<QV8SqlDatabaseResource>(args.This());
     if (!r || r->type != QV8SqlDatabaseResource::Rows)
-        V8THROW_REFERENCE("Not a SQLDatabase::Rows object");
+        V4THROW_REFERENCE("Not a SQLDatabase::Rows object");
 
     return qmlsqldatabase_rows_index(r, args.Length()?args[0]->Uint32Value():0);
 }
 
-static v8::Handle<v8::Value> qmlsqldatabase_executeSql(const v8::Arguments& args)
+static QV4::Value qmlsqldatabase_executeSql(const v8::Arguments& args)
 {
     QV8SqlDatabaseResource *r = v8_resource_cast<QV8SqlDatabaseResource>(args.This());
     if (!r || r->type != QV8SqlDatabaseResource::Query)
-        V8THROW_REFERENCE("Not a SQLDatabase::Query object");
+        V4THROW_REFERENCE("Not a SQLDatabase::Query object");
 
     QV8Engine *engine = r->engine;
 
     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 = args[0]->v4Value().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 = QV4::Value::undefinedValue();
+    QV4::Value result = QV4::Value::undefinedValue();
 
     if (query.prepare(sql)) {
         if (args.Length() > 1) {
@@ -281,12 +292,12 @@ static v8::Handle<v8::Value> qmlsqldatabase_executeSql(const v8::Arguments& args
             r->query = query;
             rows->SetExternalResource(r);
 
-            v8::Handle<v8::Object> resultObject = v8::Object::New();
-            result = resultObject;
+            QV4::Object *resultObject = QV8Engine::getV4(engine)->newObject();
+            result = QV4::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(QV8Engine::getV4(engine)->current, QV8Engine::getV4(engine)->newIdentifier("rowsAffected"), QV4::Value::fromInt32(query.numRowsAffected()));
+            resultObject->put(QV8Engine::getV4(engine)->current, QV8Engine::getV4(engine)->newIdentifier("insertId"), engine->toString(query.lastInsertId().toString()));
+            resultObject->put(QV8Engine::getV4(engine)->current, QV8Engine::getV4(engine)->newIdentifier("rows"), rows->v4Value());
         } else {
             err = true;
         }
@@ -294,19 +305,19 @@ 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 QV4::Value qmlsqldatabase_changeVersion(const v8::Arguments& args)
 {
     if (args.Length() < 2)
         return QV4::Value::undefinedValue();
 
     QV8SqlDatabaseResource *r = v8_resource_cast<QV8SqlDatabaseResource>(args.This());
     if (!r || r->type != QV8SqlDatabaseResource::Database)
-        V8THROW_REFERENCE("Not a SQLDatabase object");
+        V4THROW_REFERENCE("Not a SQLDatabase object");
 
     QV8Engine *engine = r->engine;
 
@@ -316,7 +327,7 @@ static v8::Handle<v8::Value> qmlsqldatabase_changeVersion(const v8::Arguments& a
     v8::Handle<v8::Value> callback = args[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::Handle<v8::Object> instance = databaseData(engine)->queryConstructor->NewInstance();
     QV8SqlDatabaseResource *r2 = new QV8SqlDatabaseResource(engine);
@@ -338,10 +349,10 @@ static v8::Handle<v8::Value> qmlsqldatabase_changeVersion(const v8::Arguments& a
         if (tc.HasCaught()) {
             db.rollback();
             tc.ReThrow();
-            return v8::Handle<v8::Value>();
+            return QV4::Value::undefinedValue();
         } else 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;
         }
@@ -360,16 +371,16 @@ static v8::Handle<v8::Value> qmlsqldatabase_changeVersion(const v8::Arguments& a
     return QV4::Value::undefinedValue();
 }
 
-static v8::Handle<v8::Value> qmlsqldatabase_transaction_shared(const v8::Arguments& args, bool readOnly)
+static QV4::Value qmlsqldatabase_transaction_shared(const v8::Arguments& args, bool readOnly)
 {
     QV8SqlDatabaseResource *r = v8_resource_cast<QV8SqlDatabaseResource>(args.This());
     if (!r || r->type != QV8SqlDatabaseResource::Database)
-        V8THROW_REFERENCE("Not a SQLDatabase object");
+        V4THROW_REFERENCE("Not a SQLDatabase object");
 
     QV8Engine *engine = r->engine;
 
     if (args.Length() == 0 || !args[0]->IsFunction())
-        V8THROW_SQL(SQLEXCEPTION_UNKNOWN_ERR,QQmlEngine::tr("transaction: missing 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]);
@@ -392,7 +403,7 @@ static v8::Handle<v8::Value> qmlsqldatabase_transaction_shared(const v8::Argumen
     if (tc.HasCaught()) {
         db.rollback();
         tc.ReThrow();
-        return v8::Handle<v8::Value>();
+        return QV4::Value::undefinedValue();
     } else if (!db.commit()) {
         db.rollback();
     }
@@ -400,12 +411,12 @@ static v8::Handle<v8::Value> qmlsqldatabase_transaction_shared(const v8::Argumen
     return QV4::Value::undefinedValue();
 }
 
-static v8::Handle<v8::Value> qmlsqldatabase_transaction(const v8::Arguments& args)
+static QV4::Value qmlsqldatabase_transaction(const v8::Arguments& args)
 {
     return qmlsqldatabase_transaction_shared(args, false);
 }
 
-static v8::Handle<v8::Value> qmlsqldatabase_read_transaction(const v8::Arguments& args)
+static QV4::Value qmlsqldatabase_read_transaction(const v8::Arguments& args)
 {
     return qmlsqldatabase_transaction_shared(args, true);
 }
diff --git a/src/particles/qquickv8particledata.cpp b/src/particles/qquickv8particledata.cpp
index 3ca88208d5..08fc1415ec 100644
--- a/src/particles/qquickv8particledata.cpp
+++ b/src/particles/qquickv8particledata.cpp
@@ -43,6 +43,7 @@
 #include "qquickv8particledata_p.h"
 #include "qquickparticlesystem_p.h"//for QQuickParticleData
 #include <QDebug>
+#include <private/qv4engine_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -286,33 +287,33 @@ public:
     v8::Persistent<v8::Function> constructor;
 };
 
-static v8::Handle<v8::Value> particleData_discard(const v8::Arguments &args)
+static QV4::Value particleData_discard(const v8::Arguments &args)
 {
     QV8ParticleDataResource *r = v8_resource_cast<QV8ParticleDataResource>(args.This());
 
     if (!r || !r->datum)
-        V8THROW_ERROR("Not a valid ParticleData object");
+        V4THROW_ERROR("Not a valid ParticleData object");
 
     r->datum->lifeSpan = 0; //Don't kill(), because it could still be in the middle of being created
     return QV4::Value::undefinedValue();
 }
 
-static v8::Handle<v8::Value> particleData_lifeLeft(const v8::Arguments &args)
+static QV4::Value particleData_lifeLeft(const v8::Arguments &args)
 {
     QV8ParticleDataResource *r = v8_resource_cast<QV8ParticleDataResource>(args.This());
     if (!r || !r->datum)
-        V8THROW_ERROR("Not a valid ParticleData object");
+        V4THROW_ERROR("Not a valid ParticleData object");
 
-    return v8::Number::New(r->datum->lifeLeft());
+    return QV4::Value::fromDouble(r->datum->lifeLeft());
 }
 
-static v8::Handle<v8::Value> particleData_curSize(const v8::Arguments &args)
+static QV4::Value particleData_curSize(const v8::Arguments &args)
 {
     QV8ParticleDataResource *r = v8_resource_cast<QV8ParticleDataResource>(args.This());
     if (!r || !r->datum)
-        V8THROW_ERROR("Not a valid ParticleData object");
+        V4THROW_ERROR("Not a valid ParticleData object");
 
-    return v8::Number::New(r->datum->curSize());
+    return QV4::Value::fromDouble(r->datum->curSize());
 }
 #define COLOR_GETTER_AND_SETTER(VAR, NAME) static v8::Handle<v8::Value> particleData_get_ ## NAME (v8::Handle<v8::String>, const v8::AccessorInfo &info) \
 { \
diff --git a/src/qml/qml/qqmlcomponent.cpp b/src/qml/qml/qqmlcomponent.cpp
index 2747cc72fc..0c020b76a3 100644
--- a/src/qml/qml/qqmlcomponent.cpp
+++ b/src/qml/qml/qqmlcomponent.cpp
@@ -1094,7 +1094,7 @@ public:
                                               const v8::AccessorInfo& info);
     static v8::Handle<v8::Value> ForceCompletionGetter(v8::Handle<v8::String>,
                                                        const v8::AccessorInfo& info);
-    static v8::Handle<v8::Value> ForceCompletion(const v8::Arguments &args);
+    static QV4::Value ForceCompletion(const v8::Arguments &args);
 
     static void StatusChangedSetter(v8::Handle<v8::String>, v8::Handle<v8::Value> value,
                                     const v8::AccessorInfo& info);
@@ -1408,11 +1408,11 @@ v8::Handle<v8::Value> QV8IncubatorResource::ForceCompletionGetter(v8::Handle<v8:
     return componentExtension(r->engine)->forceCompletion;
 }
 
-v8::Handle<v8::Value> QV8IncubatorResource::ForceCompletion(const v8::Arguments &args) 
+QV4::Value QV8IncubatorResource::ForceCompletion(const v8::Arguments &args)
 {
     QV8IncubatorResource *r = v8_resource_cast<QV8IncubatorResource>(args.This());
     if (!r)
-        V8THROW_TYPE("Not an incubator object");
+        V4THROW_TYPE("Not an incubator object");
 
     r->forceCompletion();
 
diff --git a/src/qml/qml/qqmllocale.cpp b/src/qml/qml/qqmllocale.cpp
index cd3b40b02d..3bb91a3079 100644
--- a/src/qml/qml/qqmllocale.cpp
+++ b/src/qml/qml/qqmllocale.cpp
@@ -63,7 +63,7 @@ public:
 #define GET_LOCALE_DATA_RESOURCE(OBJECT) \
 QV8LocaleDataResource *r = v8_resource_cast<QV8LocaleDataResource>(OBJECT); \
 if (!r) \
-    V8THROW_ERROR("Not a valid Locale object")
+    V4THROW_ERROR("Not a valid Locale object")
 
 static bool isLocaleObject(v8::Handle<v8::Value> val)
 {
@@ -161,7 +161,7 @@ void QQmlDateExtension::registerExtension(QV8Engine *engine)
     registerFunction(engine, dateTimeZoneUpdatedFunction, timeZoneUpdated);
 }
 
-v8::Handle<v8::Value> QQmlDateExtension::toLocaleString(const v8::Arguments& args)
+QV4::Value QQmlDateExtension::toLocaleString(const v8::Arguments& args)
 {
     if (args.Length() > 2)
         return QV4::Value::undefinedValue();
@@ -193,7 +193,7 @@ v8::Handle<v8::Value> QQmlDateExtension::toLocaleString(const v8::Arguments& arg
             QLocale::FormatType format = QLocale::FormatType(intFormat);
             formattedDt = r->locale.toString(dt, format);
         } else {
-            V8THROW_ERROR("Locale: Date.toLocaleString(): Invalid datetime format");
+            V4THROW_ERROR("Locale: Date.toLocaleString(): Invalid datetime format");
         }
     } else {
          formattedDt = r->locale.toString(dt, enumFormat);
@@ -202,7 +202,7 @@ v8::Handle<v8::Value> QQmlDateExtension::toLocaleString(const v8::Arguments& arg
     return r->engine->toString(formattedDt);
 }
 
-v8::Handle<v8::Value> QQmlDateExtension::toLocaleTimeString(const v8::Arguments& args)
+QV4::Value QQmlDateExtension::toLocaleTimeString(const v8::Arguments& args)
 {
     if (args.Length() > 2)
         return QV4::Value::undefinedValue();
@@ -235,7 +235,7 @@ v8::Handle<v8::Value> QQmlDateExtension::toLocaleTimeString(const v8::Arguments&
             QLocale::FormatType format = QLocale::FormatType(intFormat);
             formattedTime = r->locale.toString(time, format);
         } else {
-            V8THROW_ERROR("Locale: Date.toLocaleTimeString(): Invalid time format");
+            V4THROW_ERROR("Locale: Date.toLocaleTimeString(): Invalid time format");
         }
     } else {
          formattedTime = r->locale.toString(time, enumFormat);
@@ -244,7 +244,7 @@ v8::Handle<v8::Value> QQmlDateExtension::toLocaleTimeString(const v8::Arguments&
     return r->engine->toString(formattedTime);
 }
 
-v8::Handle<v8::Value> QQmlDateExtension::toLocaleDateString(const v8::Arguments& args)
+QV4::Value QQmlDateExtension::toLocaleDateString(const v8::Arguments& args)
 {
     if (args.Length() > 2)
         return QV4::Value::undefinedValue();
@@ -277,7 +277,7 @@ v8::Handle<v8::Value> QQmlDateExtension::toLocaleDateString(const v8::Arguments&
             QLocale::FormatType format = QLocale::FormatType(intFormat);
             formattedDate = r->locale.toString(date, format);
         } else {
-            V8THROW_ERROR("Locale: Date.loLocaleDateString(): Invalid date format");
+            V4THROW_ERROR("Locale: Date.loLocaleDateString(): Invalid date format");
         }
     } else {
          formattedDate = r->locale.toString(date, enumFormat);
@@ -286,7 +286,7 @@ v8::Handle<v8::Value> QQmlDateExtension::toLocaleDateString(const v8::Arguments&
     return r->engine->toString(formattedDate);
 }
 
-v8::Handle<v8::Value> QQmlDateExtension::fromLocaleString(const v8::Arguments& args)
+QV4::Value QQmlDateExtension::fromLocaleString(const v8::Arguments& args)
 {
     QV4::ExecutionEngine *engine = args.GetIsolate()->GetEngine();
     if (args.Length() == 1 && args[0]->IsString()) {
@@ -297,7 +297,7 @@ v8::Handle<v8::Value> QQmlDateExtension::fromLocaleString(const v8::Arguments& a
     }
 
     if (args.Length() < 1 || args.Length() > 3 || !isLocaleObject(args[0]))
-        V8THROW_ERROR("Locale: Date.fromLocaleString(): Invalid arguments");
+        V4THROW_ERROR("Locale: Date.fromLocaleString(): Invalid arguments");
 
     GET_LOCALE_DATA_RESOURCE(args[0]->ToObject());
 
@@ -313,7 +313,7 @@ v8::Handle<v8::Value> QQmlDateExtension::fromLocaleString(const v8::Arguments& a
             QLocale::FormatType format = QLocale::FormatType(intFormat);
             dt = r->locale.toDateTime(dateString, format);
         } else {
-            V8THROW_ERROR("Locale: Date.fromLocaleString(): Invalid datetime format");
+            V4THROW_ERROR("Locale: Date.fromLocaleString(): Invalid datetime format");
         }
     } else {
         dt = r->locale.toDateTime(dateString, enumFormat);
@@ -322,7 +322,7 @@ v8::Handle<v8::Value> QQmlDateExtension::fromLocaleString(const v8::Arguments& a
     return QV4::Value::fromObject(engine->newDateObject(dt));
 }
 
-v8::Handle<v8::Value> QQmlDateExtension::fromLocaleTimeString(const v8::Arguments& args)
+QV4::Value QQmlDateExtension::fromLocaleTimeString(const v8::Arguments& args)
 {
     QV4::ExecutionEngine *engine = args.GetIsolate()->GetEngine();
 
@@ -336,7 +336,7 @@ v8::Handle<v8::Value> QQmlDateExtension::fromLocaleTimeString(const v8::Argument
     }
 
     if (args.Length() < 1 || args.Length() > 3 || !isLocaleObject(args[0]))
-        V8THROW_ERROR("Locale: Date.fromLocaleTimeString(): Invalid arguments");
+        V4THROW_ERROR("Locale: Date.fromLocaleTimeString(): Invalid arguments");
 
     GET_LOCALE_DATA_RESOURCE(args[0]->ToObject());
 
@@ -352,7 +352,7 @@ v8::Handle<v8::Value> QQmlDateExtension::fromLocaleTimeString(const v8::Argument
             QLocale::FormatType format = QLocale::FormatType(intFormat);
             tm = r->locale.toTime(dateString, format);
         } else {
-            V8THROW_ERROR("Locale: Date.fromLocaleTimeString(): Invalid datetime format");
+            V4THROW_ERROR("Locale: Date.fromLocaleTimeString(): Invalid datetime format");
         }
     } else {
         tm = r->locale.toTime(dateString, enumFormat);
@@ -364,7 +364,7 @@ v8::Handle<v8::Value> QQmlDateExtension::fromLocaleTimeString(const v8::Argument
     return QV4::Value::fromObject(engine->newDateObject(dt));
 }
 
-v8::Handle<v8::Value> QQmlDateExtension::fromLocaleDateString(const v8::Arguments& args)
+QV4::Value QQmlDateExtension::fromLocaleDateString(const v8::Arguments& args)
 {
     QV4::ExecutionEngine *engine = args.GetIsolate()->GetEngine();
 
@@ -376,7 +376,7 @@ v8::Handle<v8::Value> QQmlDateExtension::fromLocaleDateString(const v8::Argument
     }
 
     if (args.Length() < 1 || args.Length() > 3 || !isLocaleObject(args[0]))
-        V8THROW_ERROR("Locale: Date.fromLocaleDateString(): Invalid arguments");
+        V4THROW_ERROR("Locale: Date.fromLocaleDateString(): Invalid arguments");
 
     GET_LOCALE_DATA_RESOURCE(args[0]->ToObject());
 
@@ -392,7 +392,7 @@ v8::Handle<v8::Value> QQmlDateExtension::fromLocaleDateString(const v8::Argument
             QLocale::FormatType format = QLocale::FormatType(intFormat);
             dt = r->locale.toDate(dateString, format);
         } else {
-            V8THROW_ERROR("Locale: Date.fromLocaleDateString(): Invalid datetime format");
+            V4THROW_ERROR("Locale: Date.fromLocaleDateString(): Invalid datetime format");
         }
     } else {
         dt = r->locale.toDate(dateString, enumFormat);
@@ -401,10 +401,10 @@ v8::Handle<v8::Value> QQmlDateExtension::fromLocaleDateString(const v8::Argument
     return QV4::Value::fromObject(engine->newDateObject(QDateTime(dt)));
 }
 
-v8::Handle<v8::Value> QQmlDateExtension::timeZoneUpdated(const v8::Arguments& args)
+QV4::Value QQmlDateExtension::timeZoneUpdated(const v8::Arguments& args)
 {
     if (args.Length() != 0)
-        V8THROW_ERROR("Locale: Date.timeZoneUpdated(): Invalid arguments");
+        V4THROW_ERROR("Locale: Date.timeZoneUpdated(): Invalid arguments");
 
     v8::Date::DateTimeConfigurationChangeNotification();
 
@@ -447,10 +447,10 @@ void QQmlNumberExtension::registerExtension(QV8Engine *engine)
     registerFunction(engine, numberFromLocaleStringFunction, fromLocaleString);
 }
 
-v8::Handle<v8::Value> QQmlNumberExtension::toLocaleString(const v8::Arguments& args)
+QV4::Value QQmlNumberExtension::toLocaleString(const v8::Arguments& args)
 {
     if (args.Length() > 3)
-        V8THROW_ERROR("Locale: Number.toLocaleString(): Invalid arguments");
+        V4THROW_ERROR("Locale: Number.toLocaleString(): Invalid arguments");
 
     double number = args.This()->ToNumber()->Value();
 
@@ -468,7 +468,7 @@ v8::Handle<v8::Value> QQmlNumberExtension::toLocaleString(const v8::Arguments& a
     uint16_t format = 'f';
     if (args.Length() > 1) {
         if (!args[1]->IsString())
-            V8THROW_ERROR("Locale: Number.toLocaleString(): Invalid arguments");
+            V4THROW_ERROR("Locale: Number.toLocaleString(): Invalid arguments");
         v8::Handle<v8::String> fs = args[1]->ToString();
         if (!fs.IsEmpty() && fs->Length()) {
             v8::String::Value value(fs);
@@ -479,17 +479,17 @@ v8::Handle<v8::Value> QQmlNumberExtension::toLocaleString(const v8::Arguments& a
     int prec = 2;
     if (args.Length() > 2) {
         if (!args[2]->IsNumber())
-            V8THROW_ERROR("Locale: Number.toLocaleString(): Invalid arguments");
+            V4THROW_ERROR("Locale: Number.toLocaleString(): Invalid arguments");
          prec = args[2]->IntegerValue();
     }
 
     return r->engine->toString(r->locale.toString(number, (char)format, prec));
 }
 
-v8::Handle<v8::Value> QQmlNumberExtension::toLocaleCurrencyString(const v8::Arguments& args)
+QV4::Value QQmlNumberExtension::toLocaleCurrencyString(const v8::Arguments& args)
 {
     if (args.Length() > 2)
-        V8THROW_ERROR("Locale: Number.toLocaleCurrencyString(): Invalid arguments");
+        V4THROW_ERROR("Locale: Number.toLocaleCurrencyString(): Invalid arguments");
 
     double number = args.This()->ToNumber()->Value();
 
@@ -500,31 +500,31 @@ v8::Handle<v8::Value> QQmlNumberExtension::toLocaleCurrencyString(const v8::Argu
     }
 
     if (!isLocaleObject(args[0]))
-        V8THROW_ERROR("Locale: Number.toLocaleCurrencyString(): Invalid arguments");
+        V4THROW_ERROR("Locale: Number.toLocaleCurrencyString(): Invalid arguments");
 
     GET_LOCALE_DATA_RESOURCE(args[0]->ToObject());
 
     QString symbol;
     if (args.Length() > 1) {
         if (!args[1]->IsString())
-            V8THROW_ERROR("Locale: Number.toLocaleString(): Invalid arguments");
+            V4THROW_ERROR("Locale: Number.toLocaleString(): Invalid arguments");
         symbol = args[1]->v4Value().toQString();
     }
 
     return r->engine->toString(r->locale.toCurrencyString(number, symbol));
 }
 
-v8::Handle<v8::Value> QQmlNumberExtension::fromLocaleString(const v8::Arguments& args)
+QV4::Value QQmlNumberExtension::fromLocaleString(const v8::Arguments& args)
 {
     if (args.Length() < 1 || args.Length() > 2)
-        V8THROW_ERROR("Locale: Number.fromLocaleString(): Invalid arguments");
+        V4THROW_ERROR("Locale: Number.fromLocaleString(): Invalid arguments");
 
     int numberIdx = 0;
     QLocale locale;
 
     if (args.Length() == 2) {
         if (!isLocaleObject(args[0]))
-            V8THROW_ERROR("Locale: Number.fromLocaleString(): Invalid arguments");
+            V4THROW_ERROR("Locale: Number.fromLocaleString(): Invalid arguments");
 
         GET_LOCALE_DATA_RESOURCE(args[0]->ToObject());
         locale = r->locale;
@@ -534,15 +534,15 @@ v8::Handle<v8::Value> QQmlNumberExtension::fromLocaleString(const v8::Arguments&
 
     v8::Handle<v8::String> ns = args[numberIdx]->ToString();
     if (ns.IsEmpty() || ns->Length() == 0)
-        return v8::Number::New(Q_QNAN);
+        return QV4::Value::fromDouble(Q_QNAN);
 
     bool ok = false;
     double val = locale.toDouble(ns->v4Value().asString()->toQString(), &ok);
 
     if (!ok)
-        V8THROW_ERROR("Locale: Number.fromLocaleString(): Invalid format")
+        V4THROW_ERROR("Locale: Number.fromLocaleString(): Invalid format")
 
-    return v8::Number::New(val);
+    return QV4::Value::fromDouble(val);
 }
 
 //--------------
@@ -599,12 +599,12 @@ static v8::Handle<v8::Value> locale_get_uiLanguages(v8::Handle<v8::String>, cons
     return result;
 }
 
-static v8::Handle<v8::Value> locale_currencySymbol(const v8::Arguments &args)
+static QV4::Value locale_currencySymbol(const v8::Arguments &args)
 {
     GET_LOCALE_DATA_RESOURCE(args.This());
 
     if (args.Length() > 1)
-        V8THROW_ERROR("Locale: currencySymbol(): Invalid arguments");
+        V4THROW_ERROR("Locale: currencySymbol(): Invalid arguments");
 
     QLocale::CurrencySymbolFormat format = QLocale::CurrencySymbol;
     if (args.Length() == 1) {
@@ -616,10 +616,10 @@ static v8::Handle<v8::Value> locale_currencySymbol(const v8::Arguments &args)
 }
 
 #define LOCALE_FORMAT(FUNC) \
-static v8::Handle<v8::Value> locale_ ##FUNC (const v8::Arguments &args) { \
+static QV4::Value locale_ ##FUNC (const v8::Arguments &args) { \
     GET_LOCALE_DATA_RESOURCE(args.This());\
     if (args.Length() > 1) \
-        V8THROW_ERROR("Locale: " #FUNC "(): Invalid arguments"); \
+        V4THROW_ERROR("Locale: " #FUNC "(): Invalid arguments"); \
     QLocale::FormatType format = QLocale::LongFormat;\
     if (args.Length() == 1) { \
         quint32 intFormat = args[0]->Uint32Value(); \
@@ -634,14 +634,14 @@ LOCALE_FORMAT(dateFormat)
 
 // +1 added to idx because JS is 0-based, whereas QLocale months begin at 1.
 #define LOCALE_FORMATTED_MONTHNAME(VARIABLE) \
-static v8::Handle<v8::Value> locale_ ## VARIABLE (const v8::Arguments &args) {\
+static QV4::Value locale_ ## VARIABLE (const v8::Arguments &args) {\
     GET_LOCALE_DATA_RESOURCE(args.This()); \
     if (args.Length() < 1 || args.Length() > 2) \
-        V8THROW_ERROR("Locale: " #VARIABLE "(): Invalid arguments"); \
+        V4THROW_ERROR("Locale: " #VARIABLE "(): Invalid arguments"); \
     QLocale::FormatType enumFormat = QLocale::LongFormat; \
     int idx = args[0]->IntegerValue() + 1; \
     if (idx < 1 || idx > 12) \
-        V8THROW_ERROR("Locale: Invalid month"); \
+        V4THROW_ERROR("Locale: Invalid month"); \
     QString name; \
     if (args.Length() == 2) { \
         if (args[1]->IsNumber()) { \
@@ -649,7 +649,7 @@ static v8::Handle<v8::Value> locale_ ## VARIABLE (const v8::Arguments &args) {\
             QLocale::FormatType format = QLocale::FormatType(intFormat); \
             name = r->locale. VARIABLE(idx, format); \
         } else { \
-            V8THROW_ERROR("Locale: Invalid datetime format"); \
+            V4THROW_ERROR("Locale: Invalid datetime format"); \
         } \
     } else { \
         name = r->locale. VARIABLE(idx, enumFormat); \
@@ -659,14 +659,14 @@ static v8::Handle<v8::Value> locale_ ## VARIABLE (const v8::Arguments &args) {\
 
 // 0 -> 7 as Qt::Sunday is 7, but Sunday is 0 in JS Date
 #define LOCALE_FORMATTED_DAYNAME(VARIABLE) \
-static v8::Handle<v8::Value> locale_ ## VARIABLE (const v8::Arguments &args) {\
+static QV4::Value locale_ ## VARIABLE (const v8::Arguments &args) {\
     GET_LOCALE_DATA_RESOURCE(args.This()); \
     if (args.Length() < 1 || args.Length() > 2) \
-        V8THROW_ERROR("Locale: " #VARIABLE "(): Invalid arguments"); \
+        V4THROW_ERROR("Locale: " #VARIABLE "(): Invalid arguments"); \
     QLocale::FormatType enumFormat = QLocale::LongFormat; \
     int idx = args[0]->IntegerValue(); \
     if (idx < 0 || idx > 7) \
-        V8THROW_ERROR("Locale: Invalid day"); \
+        V4THROW_ERROR("Locale: Invalid day"); \
     if (idx == 0) idx = 7; \
     QString name; \
     if (args.Length() == 2) { \
@@ -675,7 +675,7 @@ static v8::Handle<v8::Value> locale_ ## VARIABLE (const v8::Arguments &args) {\
             QLocale::FormatType format = QLocale::FormatType(intFormat); \
             name = r->locale. VARIABLE(idx, format); \
         } else { \
-            V8THROW_ERROR("Locale: Invalid datetime format"); \
+            V4THROW_ERROR("Locale: Invalid datetime format"); \
         } \
     } else { \
         name = r->locale. VARIABLE(idx, enumFormat); \
@@ -871,7 +871,7 @@ QQmlLocale::~QQmlLocale()
 {
 }
 
-v8::Handle<v8::Value> QQmlLocale::locale(QV8Engine *v8engine, const QString &locale)
+QV4::Value QQmlLocale::locale(QV8Engine *v8engine, const QString &locale)
 {
     QV8LocaleDataDeletable *d = localeV8Data(v8engine);
     v8::Handle<v8::Object> v8Value = d->constructor->NewInstance();
@@ -882,7 +882,7 @@ v8::Handle<v8::Value> QQmlLocale::locale(QV8Engine *v8engine, const QString &loc
         r->locale = QLocale(locale);
     v8Value->SetExternalResource(r);
 
-    return v8Value;
+    return v8Value->v4Value();
 }
 
 static const char localeCompareFunction[] =
@@ -901,7 +901,7 @@ void QQmlLocale::registerStringLocaleCompare(QV8Engine *engine)
     registerFunction(engine, localeCompareFunction, localeCompare);
 }
 
-v8::Handle<v8::Value> QQmlLocale::localeCompare(const v8::Arguments &args)
+QV4::Value QQmlLocale::localeCompare(const v8::Arguments &args)
 {
     if (args.Length() != 1 || (!args[0]->IsString() && !args[0]->IsStringObject()))
         return QV4::Value::undefinedValue();
@@ -912,7 +912,7 @@ v8::Handle<v8::Value> QQmlLocale::localeCompare(const v8::Arguments &args)
     QString thisString = args.This()->v4Value().toString(args.GetIsolate()->GetEngine()->current)->toQString();
     QString thatString = args[0]->v4Value().toString(args.GetIsolate()->GetEngine()->current)->toQString();
 
-    return v8::Integer::New(QString::localeAwareCompare(thisString, thatString));
+    return QV4::Value::fromInt32(QString::localeAwareCompare(thisString, thatString));
 }
 
 /*!
diff --git a/src/qml/qml/qqmllocale_p.h b/src/qml/qml/qqmllocale_p.h
index 25f98d9168..dcc9746cc8 100644
--- a/src/qml/qml/qqmllocale_p.h
+++ b/src/qml/qml/qqmllocale_p.h
@@ -58,13 +58,13 @@ public:
     static void registerExtension(QV8Engine *engine);
 
 private:
-    static v8::Handle<v8::Value> toLocaleString(const v8::Arguments& args);
-    static v8::Handle<v8::Value> toLocaleTimeString(const v8::Arguments& args);
-    static v8::Handle<v8::Value> toLocaleDateString(const v8::Arguments& args);
-    static v8::Handle<v8::Value> fromLocaleString(const v8::Arguments& args);
-    static v8::Handle<v8::Value> fromLocaleTimeString(const v8::Arguments& args);
-    static v8::Handle<v8::Value> fromLocaleDateString(const v8::Arguments& args);
-    static v8::Handle<v8::Value> timeZoneUpdated(const v8::Arguments& args);
+    static QV4::Value toLocaleString(const v8::Arguments& args);
+    static QV4::Value toLocaleTimeString(const v8::Arguments& args);
+    static QV4::Value toLocaleDateString(const v8::Arguments& args);
+    static QV4::Value fromLocaleString(const v8::Arguments& args);
+    static QV4::Value fromLocaleTimeString(const v8::Arguments& args);
+    static QV4::Value fromLocaleDateString(const v8::Arguments& args);
+    static QV4::Value timeZoneUpdated(const v8::Arguments& args);
 };
 
 
@@ -74,9 +74,9 @@ public:
     static void registerExtension(QV8Engine *engine);
 
 private:
-    static v8::Handle<v8::Value> toLocaleString(const v8::Arguments& args);
-    static v8::Handle<v8::Value> fromLocaleString(const v8::Arguments& args);
-    static v8::Handle<v8::Value> toLocaleCurrencyString(const v8::Arguments&  args);
+    static QV4::Value toLocaleString(const v8::Arguments& args);
+    static QV4::Value fromLocaleString(const v8::Arguments& args);
+    static QV4::Value toLocaleCurrencyString(const v8::Arguments&  args);
 };
 
 
@@ -118,14 +118,14 @@ public:
         Saturday = Qt::Saturday
     };
 
-    static v8::Handle<v8::Value> locale(QV8Engine *v8engine, const QString &lang);
+    static QV4::Value locale(QV8Engine *v8engine, const QString &lang);
 
     static void registerStringLocaleCompare(QV8Engine *engine);
 
 private:
     QQmlLocale();
 
-    static v8::Handle<v8::Value> localeCompare(const v8::Arguments &args);
+    static QV4::Value localeCompare(const v8::Arguments &args);
 };
 
 
diff --git a/src/qml/qml/qqmlxmlhttprequest.cpp b/src/qml/qml/qqmlxmlhttprequest.cpp
index 46ffbb46f8..608ebad985 100644
--- a/src/qml/qml/qqmlxmlhttprequest.cpp
+++ b/src/qml/qml/qqmlxmlhttprequest.cpp
@@ -50,6 +50,7 @@
 #include "qqmlexpression_p.h"
 #include "qqmlglobal_p.h"
 #include <private/qv4domerrors_p.h>
+#include <private/qv4engine_p.h>
 
 #include <QtCore/qobject.h>
 #include <QtQml/qjsvalue.h>
@@ -67,6 +68,9 @@
     return v8::Handle<v8::Value>(); \
 }
 
+#define V4THROW_REFERENCE(string) \
+    v8::Isolate::GetEngine()->current->throwError(QV4::Value::fromObject(v8::Isolate::GetEngine()->newReferenceErrorObject(QStringLiteral(string))))
+
 #define D(arg) (arg)->release()
 #define A(arg) (arg)->addref()
 
@@ -977,9 +981,9 @@ public:
     int replyStatus() const;
     QString replyStatusText() const;
 
-    v8::Handle<v8::Value> open(v8::Handle<v8::Object> me, const QString &, const QUrl &);
-    v8::Handle<v8::Value> send(v8::Handle<v8::Object> me, const QByteArray &);
-    v8::Handle<v8::Value> abort(v8::Handle<v8::Object> me);
+    QV4::Value open(v8::Handle<v8::Object> me, const QString &, const QUrl &);
+    QV4::Value send(v8::Handle<v8::Object> me, const QByteArray &);
+    QV4::Value abort(v8::Handle<v8::Object> me);
 
     void addHeader(const QString &, const QString &);
     QString header(const QString &name);
@@ -1073,7 +1077,7 @@ QString QQmlXMLHttpRequest::replyStatusText() const
     return m_statusText;
 }
 
-v8::Handle<v8::Value> QQmlXMLHttpRequest::open(v8::Handle<v8::Object> me, const QString &method, 
+QV4::Value QQmlXMLHttpRequest::open(v8::Handle<v8::Object> me, const QString &method,
                                                        const QUrl &url)
 {
     destroyNetwork();
@@ -1199,7 +1203,7 @@ void QQmlXMLHttpRequest::requestFromUrl(const QUrl &url)
                      this, SLOT(finished()));
 }
 
-v8::Handle<v8::Value> QQmlXMLHttpRequest::send(v8::Handle<v8::Object> me, const QByteArray &data)
+QV4::Value QQmlXMLHttpRequest::send(v8::Handle<v8::Object> me, const QByteArray &data)
 {
     m_errorFlag = false;
     m_sendFlag = true;
@@ -1213,7 +1217,7 @@ v8::Handle<v8::Value> QQmlXMLHttpRequest::send(v8::Handle<v8::Object> me, const
     return QV4::Value::undefinedValue();
 }
 
-v8::Handle<v8::Value> QQmlXMLHttpRequest::abort(v8::Handle<v8::Object> me)
+QV4::Value QQmlXMLHttpRequest::abort(v8::Handle<v8::Object> me)
 {
     destroyNetwork();
     m_responseEntityBody = QByteArray();
@@ -1511,14 +1515,14 @@ void QQmlXMLHttpRequest::destroyNetwork()
 }
 
 // XMLHttpRequest methods
-static v8::Handle<v8::Value> qmlxmlhttprequest_open(const v8::Arguments &args)
+static QV4::Value qmlxmlhttprequest_open(const v8::Arguments &args)
 {
     QQmlXMLHttpRequest *r = v8_resource_cast<QQmlXMLHttpRequest>(args.This());
     if (!r)
-        V8THROW_REFERENCE("Not an XMLHttpRequest object");
+        V4THROW_REFERENCE("Not an XMLHttpRequest object");
 
     if (args.Length() < 2 || args.Length() > 5)
-        V8THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "Incorrect argument count");
+        V4THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "Incorrect argument count");
 
     QV8Engine *engine = r->engine;
 
@@ -1529,7 +1533,7 @@ static v8::Handle<v8::Value> qmlxmlhttprequest_open(const v8::Arguments &args)
         method != QLatin1String("HEAD") &&
         method != QLatin1String("POST") &&
         method != QLatin1String("DELETE"))
-        V8THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "Unsupported HTTP method type");
+        V4THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "Unsupported HTTP method type");
 
     // Argument 1 - URL
     QUrl url = QUrl(args[1]->v4Value().toQString());
@@ -1539,7 +1543,7 @@ static v8::Handle<v8::Value> qmlxmlhttprequest_open(const v8::Arguments &args)
 
     // Argument 2 - async (optional)
     if (args.Length() > 2 && !args[2]->BooleanValue())
-        V8THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "Synchronous XMLHttpRequest calls are not supported");
+        V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "Synchronous XMLHttpRequest calls are not supported");
 
     // Argument 3/4 - user/pass (optional)
     QString username, password;
@@ -1558,17 +1562,17 @@ static v8::Handle<v8::Value> qmlxmlhttprequest_open(const v8::Arguments &args)
     return r->open(constructMeObject(args.This(), engine), method, url);
 }
 
-static v8::Handle<v8::Value> qmlxmlhttprequest_setRequestHeader(const v8::Arguments &args)
+static QV4::Value qmlxmlhttprequest_setRequestHeader(const v8::Arguments &args)
 {
     QQmlXMLHttpRequest *r = v8_resource_cast<QQmlXMLHttpRequest>(args.This());
     if (!r)
-        V8THROW_REFERENCE("Not an XMLHttpRequest object");
+        V4THROW_REFERENCE("Not an XMLHttpRequest object");
 
     if (args.Length() != 2)
-        V8THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "Incorrect argument count");
+        V4THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "Incorrect argument count");
 
     if (r->readyState() != QQmlXMLHttpRequest::Opened || r->sendFlag())
-        V8THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
+        V4THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
 
     QV8Engine *engine = r->engine;
 
@@ -1605,17 +1609,17 @@ static v8::Handle<v8::Value> qmlxmlhttprequest_setRequestHeader(const v8::Argume
     return QV4::Value::undefinedValue();
 }
 
-static v8::Handle<v8::Value> qmlxmlhttprequest_send(const v8::Arguments &args)
+static QV4::Value qmlxmlhttprequest_send(const v8::Arguments &args)
 {
     QQmlXMLHttpRequest *r = v8_resource_cast<QQmlXMLHttpRequest>(args.This());
     if (!r)
-        V8THROW_REFERENCE("Not an XMLHttpRequest object");
+        V4THROW_REFERENCE("Not an XMLHttpRequest object");
 
     QV8Engine *engine = r->engine;
 
     if (r->readyState() != QQmlXMLHttpRequest::Opened ||
         r->sendFlag())
-        V8THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
+        V4THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
 
     QByteArray data;
     if (args.Length() > 0)
@@ -1624,49 +1628,49 @@ static v8::Handle<v8::Value> qmlxmlhttprequest_send(const v8::Arguments &args)
     return r->send(constructMeObject(args.This(), engine), data);
 }
 
-static v8::Handle<v8::Value> qmlxmlhttprequest_abort(const v8::Arguments &args)
+static QV4::Value qmlxmlhttprequest_abort(const v8::Arguments &args)
 {
     QQmlXMLHttpRequest *r = v8_resource_cast<QQmlXMLHttpRequest>(args.This());
     if (!r)
-        V8THROW_REFERENCE("Not an XMLHttpRequest object");
+        V4THROW_REFERENCE("Not an XMLHttpRequest object");
 
     return r->abort(constructMeObject(args.This(), r->engine));
 }
 
-static v8::Handle<v8::Value> qmlxmlhttprequest_getResponseHeader(const v8::Arguments &args)
+static QV4::Value qmlxmlhttprequest_getResponseHeader(const v8::Arguments &args)
 {
     QQmlXMLHttpRequest *r = v8_resource_cast<QQmlXMLHttpRequest>(args.This());
     if (!r)
-        V8THROW_REFERENCE("Not an XMLHttpRequest object");
+        V4THROW_REFERENCE("Not an XMLHttpRequest object");
 
     QV8Engine *engine = r->engine;
 
     if (args.Length() != 1)
-        V8THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "Incorrect argument count");
+        V4THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "Incorrect argument count");
 
     if (r->readyState() != QQmlXMLHttpRequest::Loading &&
         r->readyState() != QQmlXMLHttpRequest::Done &&
         r->readyState() != QQmlXMLHttpRequest::HeadersReceived)
-        V8THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
+        V4THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
 
     return engine->toString(r->header(args[0]->v4Value().toQString()));
 }
 
-static v8::Handle<v8::Value> qmlxmlhttprequest_getAllResponseHeaders(const v8::Arguments &args)
+static QV4::Value qmlxmlhttprequest_getAllResponseHeaders(const v8::Arguments &args)
 {
     QQmlXMLHttpRequest *r = v8_resource_cast<QQmlXMLHttpRequest>(args.This());
     if (!r)
-        V8THROW_REFERENCE("Not an XMLHttpRequest object");
+        V4THROW_REFERENCE("Not an XMLHttpRequest object");
 
     QV8Engine *engine = r->engine;
 
     if (args.Length() != 0) 
-        V8THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "Incorrect argument count");
+        V4THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "Incorrect argument count");
 
     if (r->readyState() != QQmlXMLHttpRequest::Loading &&
         r->readyState() != QQmlXMLHttpRequest::Done &&
         r->readyState() != QQmlXMLHttpRequest::HeadersReceived)
-        V8THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
+        V4THROW_DOM(DOMEXCEPTION_INVALID_STATE_ERR, "Invalid state");
 
     return engine->toString(r->headers());
 }
@@ -1750,7 +1754,7 @@ static v8::Handle<v8::Value> qmlxmlhttprequest_responseXML(v8::Handle<v8::String
     }
 }
 
-static v8::Handle<v8::Value> qmlxmlhttprequest_new(const v8::Arguments &args)
+static QV4::Value qmlxmlhttprequest_new(const v8::Arguments &args)
 {
     if (args.IsConstructCall()) {
         QV8Engine *engine = V8ENGINE();
@@ -1759,7 +1763,7 @@ static v8::Handle<v8::Value> qmlxmlhttprequest_new(const v8::Arguments &args)
         QQmlXMLHttpRequest *r = new QQmlXMLHttpRequest(engine, engine->networkAccessManager());
         args.This()->SetExternalResource(r);
 
-        return args.This();
+        return args.This()->v4Value();
     } else {
         return QV4::Value::undefinedValue();
     }
diff --git a/src/qml/qml/v4/qv4context_p.h b/src/qml/qml/v4/qv4context_p.h
index 1043965b46..5b694a22bf 100644
--- a/src/qml/qml/v4/qv4context_p.h
+++ b/src/qml/qml/v4/qv4context_p.h
@@ -74,7 +74,7 @@ struct Q_QML_EXPORT DiagnosticMessage
 
 struct CallContext;
 
-struct ExecutionContext
+struct Q_QML_EXPORT ExecutionContext
 {
     enum Type {
         Type_GlobalContext = 0x1,
diff --git a/src/qml/qml/v4/qv4v8.cpp b/src/qml/qml/v4/qv4v8.cpp
index 7b2345112b..f65ad0dab8 100644
--- a/src/qml/qml/v4/qv4v8.cpp
+++ b/src/qml/qml/v4/qv4v8.cpp
@@ -1354,6 +1354,11 @@ Handle<Object> Arguments::This() const
     return m_thisObject;
 }
 
+QV4::Value Arguments::ThisV4() const
+{
+    return m_thisObject->v4Value();
+}
+
 Handle<Object> Arguments::Holder() const
 {
     // ### FIXME.
@@ -1641,7 +1646,7 @@ protected:
         Arguments arguments(args, argc, thisObject, false, that->m_functionTemplate->m_data);
         QV4::Value result = QV4::Value::undefinedValue();
         if (that->m_functionTemplate->m_callback)
-            result = that->m_functionTemplate->m_callback(arguments)->v4Value();
+            result = that->m_functionTemplate->m_callback(arguments);
         return result;
     }
 
@@ -1657,7 +1662,7 @@ protected:
 
         QV4::Value result = QV4::Value::undefinedValue();
         if (that->m_functionTemplate->m_callback)
-            result = that->m_functionTemplate->m_callback(arguments)->v4Value();
+            result = that->m_functionTemplate->m_callback(arguments);
         if (result.isObject())
             return result;
         return QV4::Value::fromObject(obj);
diff --git a/src/qml/qml/v4/qv4v8_p.h b/src/qml/qml/v4/qv4v8_p.h
index 113ac11615..ca68ae2638 100644
--- a/src/qml/qml/v4/qv4v8_p.h
+++ b/src/qml/qml/v4/qv4v8_p.h
@@ -1622,6 +1622,7 @@ class V8EXPORT Arguments {
   int Length() const;
   Handle<Value> operator[](int i) const;
   Handle<Object> This() const;
+  QV4::Value ThisV4() const;
   Handle<Object> Holder() const;
   bool IsConstructCall() const;
   Handle<Value> Data() const;
@@ -1652,7 +1653,7 @@ private:
 };
 
 
-typedef Handle<Value> (*InvocationCallback)(const Arguments& args);
+typedef QV4::Value (*InvocationCallback)(const Arguments& args);
 
 /**
  * NamedProperty[Getter|Setter] are used as interceptors on object.
diff --git a/src/qml/qml/v8/qqmlbuiltinfunctions.cpp b/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
index 81f013d364..a967407788 100644
--- a/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
+++ b/src/qml/qml/v8/qqmlbuiltinfunctions.cpp
@@ -52,6 +52,8 @@
 #include <private/qqmlprofilerservice_p.h>
 #include <private/qqmlglobal_p.h>
 
+#include <private/qv4engine_p.h>
+
 #include <QtCore/qstring.h>
 #include <QtCore/qdatetime.h>
 #include <QtCore/qcryptographichash.h>
@@ -107,7 +109,7 @@ static QString jsStack() {
     return stackFrames.join(QLatin1String("\n"));
 }
 
-v8::Handle<v8::Value> console(ConsoleLogTypes logType, const v8::Arguments &args,
+QV4::Value console(ConsoleLogTypes logType, const v8::Arguments &args,
                               bool printStack = false)
 {
     QString result;
@@ -173,7 +175,7 @@ v8::Handle<v8::Value> console(ConsoleLogTypes logType, const v8::Arguments &args
     return QV4::Value::undefinedValue();
 }
 
-v8::Handle<v8::Value> gc(const v8::Arguments &args)
+QV4::Value gc(const v8::Arguments &args)
 {
     Q_UNUSED(args);
     // ###
@@ -181,12 +183,12 @@ v8::Handle<v8::Value> gc(const v8::Arguments &args)
     return QV4::Value::undefinedValue();
 }
 
-v8::Handle<v8::Value> consoleError(const v8::Arguments &args)
+QV4::Value consoleError(const v8::Arguments &args)
 {
     return console(Error, args);
 }
 
-v8::Handle<v8::Value> consoleLog(const v8::Arguments &args)
+QV4::Value consoleLog(const v8::Arguments &args)
 {
     //console.log
     //console.debug
@@ -195,7 +197,7 @@ v8::Handle<v8::Value> consoleLog(const v8::Arguments &args)
     return console(Log, args);
 }
 
-v8::Handle<v8::Value> consoleProfile(const v8::Arguments &args)
+QV4::Value consoleProfile(const v8::Arguments &args)
 {
     //DeclarativeDebugTrace cannot handle nested profiling
     //although v8 can handle several profiling at once,
@@ -224,7 +226,7 @@ v8::Handle<v8::Value> consoleProfile(const v8::Arguments &args)
     return QV4::Value::undefinedValue();
 }
 
-v8::Handle<v8::Value> consoleProfileEnd(const v8::Arguments &args)
+QV4::Value consoleProfileEnd(const v8::Arguments &args)
 {
     //DeclarativeDebugTrace cannot handle nested profiling
     //although v8 can handle several profiling at once,
@@ -253,19 +255,19 @@ v8::Handle<v8::Value> consoleProfileEnd(const v8::Arguments &args)
     return QV4::Value::undefinedValue();
 }
 
-v8::Handle<v8::Value> consoleTime(const v8::Arguments &args)
+QV4::Value consoleTime(const v8::Arguments &args)
 {
     if (args.Length() != 1)
-        V8THROW_ERROR("console.time(): Invalid arguments");
+        V4THROW_ERROR("console.time(): Invalid arguments");
     QString name = args[0]->v4Value().toQString();
     V8ENGINE()->startTimer(name);
     return QV4::Value::undefinedValue();
 }
 
-v8::Handle<v8::Value> consoleTimeEnd(const v8::Arguments &args)
+QV4::Value consoleTimeEnd(const v8::Arguments &args)
 {
     if (args.Length() != 1)
-        V8THROW_ERROR("console.time(): Invalid arguments");
+        V4THROW_ERROR("console.time(): Invalid arguments");
     QString name = args[0]->v4Value().toQString();
     bool wasRunning;
     qint64 elapsed = V8ENGINE()->stopTimer(name, &wasRunning);
@@ -275,7 +277,7 @@ v8::Handle<v8::Value> consoleTimeEnd(const v8::Arguments &args)
     return QV4::Value::undefinedValue();
 }
 
-v8::Handle<v8::Value> consoleCount(const v8::Arguments &args)
+QV4::Value consoleCount(const v8::Arguments &args)
 {
     // first argument: name to print. Ignore any additional arguments
     QString name;
@@ -303,10 +305,10 @@ v8::Handle<v8::Value> consoleCount(const v8::Arguments &args)
     return QV4::Value::undefinedValue();
 }
 
-v8::Handle<v8::Value> consoleTrace(const v8::Arguments &args)
+QV4::Value consoleTrace(const v8::Arguments &args)
 {
     if (args.Length() != 0)
-        V8THROW_ERROR("console.trace(): Invalid arguments");
+        V4THROW_ERROR("console.trace(): Invalid arguments");
 
     QString stack = jsStack();
 
@@ -320,15 +322,15 @@ v8::Handle<v8::Value> consoleTrace(const v8::Arguments &args)
     return QV4::Value::undefinedValue();
 }
 
-v8::Handle<v8::Value> consoleWarn(const v8::Arguments &args)
+QV4::Value consoleWarn(const v8::Arguments &args)
 {
     return console(Warn, args);
 }
 
-v8::Handle<v8::Value> consoleAssert(const v8::Arguments &args)
+QV4::Value consoleAssert(const v8::Arguments &args)
 {
     if (args.Length() == 0)
-        V8THROW_ERROR("console.assert(): Missing argument");
+        V4THROW_ERROR("console.assert(): Missing argument");
 
     if (!args[0]->ToBoolean()->Value()) {
         QString message;
@@ -354,21 +356,21 @@ v8::Handle<v8::Value> consoleAssert(const v8::Arguments &args)
     return QV4::Value::undefinedValue();
 }
 
-v8::Handle<v8::Value> consoleException(const v8::Arguments &args)
+QV4::Value consoleException(const v8::Arguments &args)
 {
     if (args.Length() == 0)
-        V8THROW_ERROR("console.exception(): Missing argument");
+        V4THROW_ERROR("console.exception(): Missing argument");
 
     console(Error, args, true);
 
     return QV4::Value::undefinedValue();
 }
 
-v8::Handle<v8::Value> stringArg(const v8::Arguments &args)
+QV4::Value stringArg(const v8::Arguments &args)
 {
     QString value = args.This()->v4Value().toQString();
     if (args.Length() != 1)
-        V8THROW_ERROR("String.arg(): Invalid arguments");
+        V4THROW_ERROR("String.arg(): Invalid arguments");
 
     v8::Handle<v8::Value> arg = args[0];
     if (arg->IsUint32())
@@ -387,12 +389,12 @@ v8::Handle<v8::Value> stringArg(const v8::Arguments &args)
 \qmlmethod bool Qt::isQtObject(object)
 Returns true if \c object is a valid reference to a Qt or QML object, otherwise false.
 */
-v8::Handle<v8::Value> isQtObject(const v8::Arguments &args)
+QV4::Value isQtObject(const v8::Arguments &args)
 {
     if (args.Length() == 0)
-        return v8::Boolean::New(false);
+        return QV4::Value::fromBoolean(false);
 
-    return v8::Boolean::New(0 != V8ENGINE()->toQObject(args[0]->v4Value()));
+    return QV4::Value::fromBoolean(0 != V8ENGINE()->toQObject(args[0]->v4Value()));
 }
 
 /*!
@@ -401,11 +403,11 @@ v8::Handle<v8::Value> isQtObject(const v8::Arguments &args)
 Returns a color with the specified \c red, \c green, \c blue and \c alpha components.
 All components should be in the range 0-1 inclusive.
 */
-v8::Handle<v8::Value> rgba(const v8::Arguments &args)
+QV4::Value rgba(const v8::Arguments &args)
 {
     int argCount = args.Length();
     if (argCount < 3 || argCount > 4)
-        V8THROW_ERROR("Qt.rgba(): Invalid arguments");
+        V4THROW_ERROR("Qt.rgba(): Invalid arguments");
 
     double r = args[0]->NumberValue();
     double g = args[1]->NumberValue();
@@ -430,11 +432,11 @@ v8::Handle<v8::Value> rgba(const v8::Arguments &args)
 Returns a color with the specified \c hue, \c saturation, \c lightness and \c alpha components.
 All components should be in the range 0-1 inclusive.
 */
-v8::Handle<v8::Value> hsla(const v8::Arguments &args)
+QV4::Value hsla(const v8::Arguments &args)
 {
     int argCount = args.Length();
     if (argCount < 3 || argCount > 4)
-        V8THROW_ERROR("Qt.hsla(): Invalid arguments");
+        V4THROW_ERROR("Qt.hsla(): Invalid arguments");
 
     double h = args[0]->NumberValue();
     double s = args[1]->NumberValue();
@@ -461,10 +463,10 @@ may be either color values or string values.  If a string value is supplied it
 must be convertible to a color, as described for the \l{colorbasictypedocs}{color}
 basic type.
 */
-v8::Handle<v8::Value> colorEqual(const v8::Arguments &args)
+QV4::Value colorEqual(const v8::Arguments &args)
 {
     if (args.Length() != 2)
-        V8THROW_ERROR("Qt.colorEqual(): Invalid arguments");
+        V4THROW_ERROR("Qt.colorEqual(): Invalid arguments");
 
     bool ok = false;
 
@@ -472,20 +474,20 @@ v8::Handle<v8::Value> colorEqual(const v8::Arguments &args)
     if (lhs.userType() == QVariant::String) {
         lhs = QQmlStringConverters::colorFromString(lhs.toString(), &ok);
         if (!ok) {
-            V8THROW_ERROR("Qt.colorEqual(): Invalid color name");
+            V4THROW_ERROR("Qt.colorEqual(): Invalid color name");
         }
     } else if (lhs.userType() != QVariant::Color) {
-        V8THROW_ERROR("Qt.colorEqual(): Invalid arguments");
+        V4THROW_ERROR("Qt.colorEqual(): Invalid arguments");
     }
 
     QVariant rhs = V8ENGINE()->toVariant(args[1]->v4Value(), -1);
     if (rhs.userType() == QVariant::String) {
         rhs = QQmlStringConverters::colorFromString(rhs.toString(), &ok);
         if (!ok) {
-            V8THROW_ERROR("Qt.colorEqual(): Invalid color name");
+            V4THROW_ERROR("Qt.colorEqual(): Invalid color name");
         }
     } else if (rhs.userType() != QVariant::Color) {
-        V8THROW_ERROR("Qt.colorEqual(): Invalid arguments");
+        V4THROW_ERROR("Qt.colorEqual(): Invalid arguments");
     }
 
     bool equal = (lhs == rhs);
@@ -499,10 +501,10 @@ Returns a \c rect with the top-left corner at \c x, \c y and the specified \c wi
 
 The returned object has \c x, \c y, \c width and \c height attributes with the given values.
 */
-v8::Handle<v8::Value> rect(const v8::Arguments &args)
+QV4::Value rect(const v8::Arguments &args)
 {
     if (args.Length() != 4)
-        V8THROW_ERROR("Qt.rect(): Invalid arguments");
+        V4THROW_ERROR("Qt.rect(): Invalid arguments");
 
     double x = args[0]->NumberValue();
     double y = args[1]->NumberValue();
@@ -516,10 +518,10 @@ v8::Handle<v8::Value> rect(const v8::Arguments &args)
 \qmlmethod point Qt::point(int x, int y)
 Returns a Point with the specified \c x and \c y coordinates.
 */
-v8::Handle<v8::Value> point(const v8::Arguments &args)
+QV4::Value point(const v8::Arguments &args)
 {
     if (args.Length() != 2)
-        V8THROW_ERROR("Qt.point(): Invalid arguments");
+        V4THROW_ERROR("Qt.point(): Invalid arguments");
 
     double x = args[0]->ToNumber()->Value();
     double y = args[1]->ToNumber()->Value();
@@ -531,10 +533,10 @@ v8::Handle<v8::Value> point(const v8::Arguments &args)
 \qmlmethod Qt::size(int width, int height)
 Returns a Size with the specified \c width and \c height.
 */
-v8::Handle<v8::Value> size(const v8::Arguments &args)
+QV4::Value size(const v8::Arguments &args)
 {
     if (args.Length() != 2)
-        V8THROW_ERROR("Qt.size(): Invalid arguments");
+        V4THROW_ERROR("Qt.size(): Invalid arguments");
 
     double w = args[0]->ToNumber()->Value();
     double h = args[1]->ToNumber()->Value();
@@ -546,10 +548,10 @@ v8::Handle<v8::Value> size(const v8::Arguments &args)
 \qmlmethod Qt::vector2d(real x, real y)
 Returns a Vector2D with the specified \c x and \c y.
 */
-v8::Handle<v8::Value> vector2d(const v8::Arguments &args)
+QV4::Value vector2d(const v8::Arguments &args)
 {
     if (args.Length() != 2)
-        V8THROW_ERROR("Qt.vector2d(): Invalid arguments");
+        V4THROW_ERROR("Qt.vector2d(): Invalid arguments");
 
     float xy[3]; // qvector2d uses float internally
     xy[0] = args[0]->ToNumber()->Value();
@@ -563,10 +565,10 @@ v8::Handle<v8::Value> vector2d(const v8::Arguments &args)
 \qmlmethod Qt::vector3d(real x, real y, real z)
 Returns a Vector3D with the specified \c x, \c y and \c z.
 */
-v8::Handle<v8::Value> vector3d(const v8::Arguments &args)
+QV4::Value vector3d(const v8::Arguments &args)
 {
     if (args.Length() != 3)
-        V8THROW_ERROR("Qt.vector3d(): Invalid arguments");
+        V4THROW_ERROR("Qt.vector3d(): Invalid arguments");
 
     float xyz[3]; // qvector3d uses float internally
     xyz[0] = args[0]->ToNumber()->Value();
@@ -581,10 +583,10 @@ v8::Handle<v8::Value> vector3d(const v8::Arguments &args)
 \qmlmethod Qt::vector4d(real x, real y, real z, real w)
 Returns a Vector4D with the specified \c x, \c y, \c z and \c w.
 */
-v8::Handle<v8::Value> vector4d(const v8::Arguments &args)
+QV4::Value vector4d(const v8::Arguments &args)
 {
     if (args.Length() != 4)
-        V8THROW_ERROR("Qt.vector4d(): Invalid arguments");
+        V4THROW_ERROR("Qt.vector4d(): Invalid arguments");
 
     float xyzw[4]; // qvector4d uses float internally
     xyzw[0] = args[0]->ToNumber()->Value();
@@ -600,10 +602,10 @@ v8::Handle<v8::Value> vector4d(const v8::Arguments &args)
 \qmlmethod Qt::quaternion(real scalar, real x, real y, real z)
 Returns a Quaternion with the specified \c scalar, \c x, \c y, and \c z.
 */
-v8::Handle<v8::Value> quaternion(const v8::Arguments &args)
+QV4::Value quaternion(const v8::Arguments &args)
 {
     if (args.Length() != 4)
-        V8THROW_ERROR("Qt.quaternion(): Invalid arguments");
+        V4THROW_ERROR("Qt.quaternion(): Invalid arguments");
 
     qreal sxyz[4]; // qquaternion uses qreal internally
     sxyz[0] = args[0]->ToNumber()->Value();
@@ -623,16 +625,16 @@ key-value pairs where valid keys are the \l{fontbasictypedocs}{font} type's
 subproperty names, and the values are valid values for each subproperty.
 Invalid keys will be ignored.
 */
-v8::Handle<v8::Value> font(const v8::Arguments &args)
+QV4::Value font(const v8::Arguments &args)
 {
     if (args.Length() != 1 || !args[0]->IsObject())
-        V8THROW_ERROR("Qt.font(): Invalid arguments");
+        V4THROW_ERROR("Qt.font(): Invalid arguments");
 
     v8::Handle<v8::Object> obj = args[0]->ToObject();
     bool ok = false;
     QVariant v = QQml_valueTypeProvider()->createVariantFromJsObject(QMetaType::QFont, QQmlV4Handle::fromV8Handle(obj), V8ENGINE(), &ok);
     if (!ok)
-        V8THROW_ERROR("Qt.font(): Invalid argument: no valid font subproperties specified");
+        V4THROW_ERROR("Qt.font(): Invalid argument: no valid font subproperties specified");
     return V8ENGINE()->fromVariant(v);
 }
 
@@ -643,19 +645,19 @@ Alternatively, the function may be called with a single argument
 where that argument is a JavaScript array which contains the sixteen
 matrix values.
 */
-v8::Handle<v8::Value> matrix4x4(const v8::Arguments &args)
+QV4::Value matrix4x4(const v8::Arguments &args)
 {
     if (args.Length() == 1 && args[0]->IsObject()) {
         v8::Handle<v8::Object> obj = args[0]->ToObject();
         bool ok = false;
         QVariant v = QQml_valueTypeProvider()->createVariantFromJsObject(QMetaType::QMatrix4x4, QQmlV4Handle::fromV8Handle(obj), V8ENGINE(), &ok);
         if (!ok)
-            V8THROW_ERROR("Qt.matrix4x4(): Invalid argument: not a valid matrix4x4 values array");
+            V4THROW_ERROR("Qt.matrix4x4(): Invalid argument: not a valid matrix4x4 values array");
         return V8ENGINE()->fromVariant(v);
     }
 
     if (args.Length() != 16)
-        V8THROW_ERROR("Qt.matrix4x4(): Invalid arguments");
+        V4THROW_ERROR("Qt.matrix4x4(): Invalid arguments");
 
     qreal vals[16]; // qmatrix4x4 uses qreal internally
     vals[0] = args[0]->ToNumber()->Value();
@@ -693,10 +695,10 @@ by factor and converts the color back to RGB.
 
 If \c factor is not supplied, returns a color 50% lighter than \c baseColor (factor 1.5).
 */
-v8::Handle<v8::Value> lighter(const v8::Arguments &args)
+QV4::Value lighter(const v8::Arguments &args)
 {
     if (args.Length() != 1 && args.Length() != 2)
-        V8THROW_ERROR("Qt.lighter(): Invalid arguments");
+        V4THROW_ERROR("Qt.lighter(): Invalid arguments");
 
     QVariant v = V8ENGINE()->toVariant(args[0]->v4Value(), -1);
     if (v.userType() == QVariant::String) {
@@ -731,10 +733,10 @@ by factor and converts the color back to RGB.
 
 If \c factor is not supplied, returns a color 50% darker than \c baseColor (factor 2.0).
 */
-v8::Handle<v8::Value> darker(const v8::Arguments &args)
+QV4::Value darker(const v8::Arguments &args)
 {
     if (args.Length() != 1 && args.Length() != 2)
-        V8THROW_ERROR("Qt.darker(): Invalid arguments");
+        V4THROW_ERROR("Qt.darker(): Invalid arguments");
 
     QVariant v = V8ENGINE()->toVariant(args[0]->v4Value(), -1);
     if (v.userType() == QVariant::String) {
@@ -778,10 +780,10 @@ v8::Handle<v8::Value> darker(const v8::Arguments &args)
 
     Tint is most useful when a subtle change is intended to be conveyed due to some event; you can then use tinting to more effectively tune the visible color.
 */
-v8::Handle<v8::Value> tint(const v8::Arguments &args)
+QV4::Value tint(const v8::Arguments &args)
 {
     if (args.Length() != 2)
-        V8THROW_ERROR("Qt.tint(): Invalid arguments");
+        V4THROW_ERROR("Qt.tint(): Invalid arguments");
 
     // base color
     QVariant v1 = V8ENGINE()->toVariant(args[0]->v4Value(), -1);
@@ -826,10 +828,10 @@ If \a format is not specified, \a date is formatted using
 
 \sa Locale
 */
-v8::Handle<v8::Value> formatDate(const v8::Arguments &args)
+QV4::Value formatDate(const v8::Arguments &args)
 {
     if (args.Length() < 1 || args.Length() > 2)
-        V8THROW_ERROR("Qt.formatDate(): Invalid arguments");
+        V4THROW_ERROR("Qt.formatDate(): Invalid arguments");
 
     Qt::DateFormat enumFormat = Qt::DefaultLocaleShortDate;
     QDate date = V8ENGINE()->toVariant(args[0]->v4Value(), -1).toDateTime().date();
@@ -843,7 +845,7 @@ v8::Handle<v8::Value> formatDate(const v8::Arguments &args)
             Qt::DateFormat format = Qt::DateFormat(intFormat);
             formattedDate = date.toString(format);
         } else {
-            V8THROW_ERROR("Qt.formatDate(): Invalid date format");
+            V4THROW_ERROR("Qt.formatDate(): Invalid date format");
         }
     } else {
          formattedDate = date.toString(enumFormat);
@@ -867,10 +869,10 @@ If \a format is not specified, \a time is formatted using
 
 \sa Locale
 */
-v8::Handle<v8::Value> formatTime(const v8::Arguments &args)
+QV4::Value formatTime(const v8::Arguments &args)
 {
     if (args.Length() < 1 || args.Length() > 2)
-        V8THROW_ERROR("Qt.formatTime(): Invalid arguments");
+        V4THROW_ERROR("Qt.formatTime(): Invalid arguments");
 
     QVariant argVariant = V8ENGINE()->toVariant(args[0]->v4Value(), -1);
     QTime time;
@@ -890,7 +892,7 @@ v8::Handle<v8::Value> formatTime(const v8::Arguments &args)
             Qt::DateFormat format = Qt::DateFormat(intFormat);
             formattedTime = time.toString(format);
         } else {
-            V8THROW_ERROR("Qt.formatTime(): Invalid time format");
+            V4THROW_ERROR("Qt.formatTime(): Invalid time format");
         }
     } else {
          formattedTime = time.toString(enumFormat);
@@ -989,10 +991,10 @@ with the \a format values below to produce the following results:
 
     \sa Locale
 */
-v8::Handle<v8::Value> formatDateTime(const v8::Arguments &args)
+QV4::Value formatDateTime(const v8::Arguments &args)
 {
     if (args.Length() < 1 || args.Length() > 2)
-        V8THROW_ERROR("Qt.formatDateTime(): Invalid arguments");
+        V4THROW_ERROR("Qt.formatDateTime(): Invalid arguments");
 
     Qt::DateFormat enumFormat = Qt::DefaultLocaleShortDate;
     QDateTime dt = V8ENGINE()->toVariant(args[0]->v4Value(), -1).toDateTime();
@@ -1006,7 +1008,7 @@ v8::Handle<v8::Value> formatDateTime(const v8::Arguments &args)
             Qt::DateFormat format = Qt::DateFormat(intFormat);
             formattedDt = dt.toString(format);
         } else {
-            V8THROW_ERROR("Qt.formatDateTime(): Invalid datetime format");
+            V4THROW_ERROR("Qt.formatDateTime(): Invalid datetime format");
         }
     } else {
          formattedDt = dt.toString(enumFormat);
@@ -1019,12 +1021,12 @@ v8::Handle<v8::Value> formatDateTime(const v8::Arguments &args)
 \qmlmethod bool Qt::openUrlExternally(url target)
 Attempts to open the specified \c target url in an external application, based on the user's desktop preferences. Returns true if it succeeds, and false otherwise.
 */
-v8::Handle<v8::Value> openUrlExternally(const v8::Arguments &args)
+QV4::Value openUrlExternally(const v8::Arguments &args)
 {
     if (args.Length() != 1)
         return V8ENGINE()->fromVariant(false);
 
-    QUrl url(V8ENGINE()->toVariant(resolvedUrl(args)->v4Value(), -1).toUrl());
+    QUrl url(V8ENGINE()->toVariant(resolvedUrl(args), -1).toUrl());
     return V8ENGINE()->fromVariant(QQml_guiProvider()->openUrlExternally(url));
 }
 
@@ -1032,7 +1034,7 @@ v8::Handle<v8::Value> openUrlExternally(const v8::Arguments &args)
   \qmlmethod url Qt::resolvedUrl(url url)
   Returns \a url resolved relative to the URL of the caller.
 */
-v8::Handle<v8::Value> resolvedUrl(const v8::Arguments &args)
+QV4::Value resolvedUrl(const v8::Arguments &args)
 {
     QUrl url = V8ENGINE()->toVariant(args[0]->v4Value(), -1).toUrl();
     QQmlEngine *e = V8ENGINE()->engine();
@@ -1053,10 +1055,10 @@ v8::Handle<v8::Value> resolvedUrl(const v8::Arguments &args)
 \qmlmethod list<string> Qt::fontFamilies()
 Returns a list of the font families available to the application.
 */
-v8::Handle<v8::Value> fontFamilies(const v8::Arguments &args)
+QV4::Value fontFamilies(const v8::Arguments &args)
 {
     if (args.Length() != 0)
-        V8THROW_ERROR("Qt.fontFamilies(): Invalid arguments");
+        V4THROW_ERROR("Qt.fontFamilies(): Invalid arguments");
 
     return V8ENGINE()->fromVariant(QVariant(QQml_guiProvider()->fontFamilies()));
 }
@@ -1065,10 +1067,10 @@ v8::Handle<v8::Value> fontFamilies(const v8::Arguments &args)
 \qmlmethod string Qt::md5(data)
 Returns a hex string of the md5 hash of \c data.
 */
-v8::Handle<v8::Value> md5(const v8::Arguments &args)
+QV4::Value md5(const v8::Arguments &args)
 {
     if (args.Length() != 1)
-        V8THROW_ERROR("Qt.md5(): Invalid arguments");
+        V4THROW_ERROR("Qt.md5(): Invalid arguments");
 
     QByteArray data = args[0]->v4Value().toQString().toUtf8();
     QByteArray result = QCryptographicHash::hash(data, QCryptographicHash::Md5);
@@ -1079,10 +1081,10 @@ v8::Handle<v8::Value> md5(const v8::Arguments &args)
 \qmlmethod string Qt::btoa(data)
 Binary to ASCII - this function returns a base64 encoding of \c data.
 */
-v8::Handle<v8::Value> btoa(const v8::Arguments &args)
+QV4::Value btoa(const v8::Arguments &args)
 {
     if (args.Length() != 1)
-        V8THROW_ERROR("Qt.btoa(): Invalid arguments");
+        V4THROW_ERROR("Qt.btoa(): Invalid arguments");
 
     QByteArray data = args[0]->v4Value().toQString().toUtf8();
 
@@ -1093,10 +1095,10 @@ v8::Handle<v8::Value> btoa(const v8::Arguments &args)
 \qmlmethod string Qt::atob(data)
 ASCII to binary - this function returns a base64 decoding of \c data.
 */
-v8::Handle<v8::Value> atob(const v8::Arguments &args)
+QV4::Value atob(const v8::Arguments &args)
 {
     if (args.Length() != 1)
-        V8THROW_ERROR("Qt.atob(): Invalid arguments");
+        V4THROW_ERROR("Qt.atob(): Invalid arguments");
 
     QByteArray data = args[0]->v4Value().toQString().toUtf8();
 
@@ -1110,7 +1112,7 @@ Within the \l {Prototyping with qmlscene}, this causes the launcher application
 to quit a C++ application when this method is called, connect the
 QQmlEngine::quit() signal to the QCoreApplication::quit() slot.
 */
-v8::Handle<v8::Value> quit(const v8::Arguments &args)
+QV4::Value quit(const v8::Arguments &args)
 {
     QQmlEnginePrivate::get(V8ENGINE()->engine())->sendQuit();
     return QV4::Value::undefinedValue();
@@ -1140,10 +1142,10 @@ If this is the case, consider using \l{QML:Qt::createComponent()}{Qt.createCompo
 
 See \l {Dynamic QML Object Creation from JavaScript} for more information on using this function.
 */
-v8::Handle<v8::Value> createQmlObject(const v8::Arguments &args)
+QV4::Value createQmlObject(const v8::Arguments &args)
 {
     if (args.Length() < 2 || args.Length() > 3)
-        V8THROW_ERROR("Qt.createQmlObject(): Invalid arguments");
+        V4THROW_ERROR("Qt.createQmlObject(): Invalid arguments");
 
     struct Error {
         static v8::Handle<v8::Value> create(QV8Engine *engine, const QList<QQmlError> &errors) {
@@ -1194,7 +1196,7 @@ v8::Handle<v8::Value> createQmlObject(const v8::Arguments &args)
 
     QObject *parentArg = v8engine->toQObject(args[1]->v4Value());
     if (!parentArg)
-        V8THROW_ERROR("Qt.createQmlObject(): Missing parent object");
+        V4THROW_ERROR("Qt.createQmlObject(): Missing parent object");
 
     QQmlComponent component(engine);
     component.setData(qml.toUtf8(), url);
@@ -1205,7 +1207,7 @@ v8::Handle<v8::Value> createQmlObject(const v8::Arguments &args)
     }
 
     if (!component.isReady())
-        V8THROW_ERROR("Qt.createQmlObject(): Component is not ready");
+        V4THROW_ERROR("Qt.createQmlObject(): Component is not ready");
 
     QObject *obj = component.beginCreate(effectiveContext);
     if (obj) {
@@ -1264,12 +1266,12 @@ See \l {Dynamic QML Object Creation from JavaScript} for more information on usi
 To create a QML object from an arbitrary string of QML (instead of a file),
 use \l{QML:Qt::createQmlObject()}{Qt.createQmlObject()}.
 */
-v8::Handle<v8::Value> createComponent(const v8::Arguments &args)
+QV4::Value createComponent(const v8::Arguments &args)
 {
-    const char *invalidArgs = "Qt.createComponent(): Invalid arguments";
-    const char *invalidParent = "Qt.createComponent(): Invalid parent object";
+    const QString invalidArgs = QStringLiteral("Qt.createComponent(): Invalid arguments");
+    const QString invalidParent = QStringLiteral("Qt.createComponent(): Invalid parent object");
     if (args.Length() < 1 || args.Length() > 3)
-        V8THROW_ERROR(invalidArgs);
+        v8::Isolate::GetEngine()->current->throwError(invalidArgs);
 
     QV8Engine *v8engine = V8ENGINE();
     QQmlEngine *engine = v8engine->engine();
@@ -1295,24 +1297,24 @@ v8::Handle<v8::Value> createComponent(const v8::Arguments &args)
         if (args[1]->IsInt32()) {
             int mode = args[1]->Int32Value();
             if (mode != int(QQmlComponent::PreferSynchronous) && mode != int(QQmlComponent::Asynchronous))
-                V8THROW_ERROR(invalidArgs);
+                v8::Isolate::GetEngine()->current->throwError(invalidArgs);
             compileMode = QQmlComponent::CompilationMode(mode);
             consumedCount += 1;
         } else {
             // The second argument could be the parent only if there are exactly two args
             if ((args.Length() != 2) || !(lastArg->IsObject() || lastArg->IsNull()))
-                V8THROW_ERROR(invalidArgs);
+                v8::Isolate::GetEngine()->current->throwError(invalidArgs);
         }
 
         if (consumedCount < args.Length()) {
             if (lastArg->IsObject()) {
                 parentArg = v8engine->toQObject(lastArg->v4Value());
                 if (!parentArg)
-                    V8THROW_ERROR(invalidParent);
+                    v8::Isolate::GetEngine()->current->throwError(invalidParent);
             } else if (lastArg->IsNull()) {
                 parentArg = 0;
             } else {
-                V8THROW_ERROR(invalidParent);
+                v8::Isolate::GetEngine()->current->throwError(invalidParent);
             }
         }
     }
@@ -1344,16 +1346,16 @@ v8::Handle<v8::Value> createComponent(const v8::Arguments &args)
 
     \sa {Localization And Internationalization Support In Qt Quick}
 */
-v8::Handle<v8::Value> qsTranslate(const v8::Arguments &args)
+QV4::Value qsTranslate(const v8::Arguments &args)
 {
     if (args.Length() < 2)
-        V8THROW_ERROR("qsTranslate() requires at least two arguments");
+        V4THROW_ERROR("qsTranslate() requires at least two arguments");
     if (!args[0]->IsString())
-        V8THROW_ERROR("qsTranslate(): first argument (context) must be a string");
+        V4THROW_ERROR("qsTranslate(): first argument (context) must be a string");
     if (!args[1]->IsString())
-        V8THROW_ERROR("qsTranslate(): second argument (sourceText) must be a string");
+        V4THROW_ERROR("qsTranslate(): second argument (sourceText) must be a string");
     if ((args.Length() > 2) && !args[2]->IsString())
-        V8THROW_ERROR("qsTranslate(): third argument (disambiguation) must be a string");
+        V4THROW_ERROR("qsTranslate(): third argument (disambiguation) must be a string");
 
     QV8Engine *v8engine = V8ENGINE();
     QString context = args[0]->v4Value().toQString();
@@ -1401,11 +1403,11 @@ v8::Handle<v8::Value> qsTranslate(const v8::Arguments &args)
 
     \sa {Localization And Internationalization Support In Qt Quick}
 */
-v8::Handle<v8::Value> qsTranslateNoOp(const v8::Arguments &args)
+QV4::Value qsTranslateNoOp(const v8::Arguments &args)
 {
     if (args.Length() < 2)
         return QV4::Value::undefinedValue();
-    return args[1];
+    return args[1]->v4Value();
 }
 
 /*!
@@ -1425,16 +1427,16 @@ v8::Handle<v8::Value> qsTranslateNoOp(const v8::Arguments &args)
 
     \sa {Localization And Internationalization Support In Qt Quick}
 */
-v8::Handle<v8::Value> qsTr(const v8::Arguments &args)
+QV4::Value qsTr(const v8::Arguments &args)
 {
     if (args.Length() < 1)
-        V8THROW_ERROR("qsTr() requires at least one argument");
+        V4THROW_ERROR("qsTr() requires at least one argument");
     if (!args[0]->IsString())
-        V8THROW_ERROR("qsTr(): first argument (sourceText) must be a string");
+        V4THROW_ERROR("qsTr(): first argument (sourceText) must be a string");
     if ((args.Length() > 1) && !args[1]->IsString())
-        V8THROW_ERROR("qsTr(): second argument (disambiguation) must be a string");
+        V4THROW_ERROR("qsTr(): second argument (disambiguation) must be a string");
     if ((args.Length() > 2) && !args[2]->IsNumber())
-        V8THROW_ERROR("qsTr(): third argument (n) must be a number");
+        V4THROW_ERROR("qsTr(): third argument (n) must be a number");
 
     QV8Engine *v8engine = V8ENGINE();
     QQmlContextData *ctxt = v8engine->callingContext();
@@ -1479,11 +1481,11 @@ v8::Handle<v8::Value> qsTr(const v8::Arguments &args)
 
     \sa {Localization And Internationalization Support In Qt Quick}
 */
-v8::Handle<v8::Value> qsTrNoOp(const v8::Arguments &args)
+QV4::Value qsTrNoOp(const v8::Arguments &args)
 {
     if (args.Length() < 1)
         return QV4::Value::undefinedValue();
-    return args[0];
+    return args[0]->v4Value();
 }
 
 /*!
@@ -1516,14 +1518,14 @@ v8::Handle<v8::Value> qsTrNoOp(const v8::Arguments &args)
 
     \sa QT_TRID_NOOP, {Localization And Internationalization Support In Qt Quick}
 */
-v8::Handle<v8::Value> qsTrId(const v8::Arguments &args)
+QV4::Value qsTrId(const v8::Arguments &args)
 {
     if (args.Length() < 1)
-        V8THROW_ERROR("qsTrId() requires at least one argument");
+        V4THROW_ERROR("qsTrId() requires at least one argument");
     if (!args[0]->IsString())
-        V8THROW_TYPE("qsTrId(): first argument (id) must be a string");
+        V4THROW_TYPE("qsTrId(): first argument (id) must be a string");
     if (args.Length() > 1 && !args[1]->IsNumber())
-        V8THROW_TYPE("qsTrId(): second argument (n) must be a number");
+        V4THROW_TYPE("qsTrId(): second argument (n) must be a number");
 
     int n = -1;
     if (args.Length() > 1)
@@ -1549,11 +1551,11 @@ v8::Handle<v8::Value> qsTrId(const v8::Arguments &args)
 
     \sa qsTrId(), {Localization And Internationalization Support In Qt Quick}
 */
-v8::Handle<v8::Value> qsTrIdNoOp(const v8::Arguments &args)
+QV4::Value qsTrIdNoOp(const v8::Arguments &args)
 {
     if (args.Length() < 1)
         return QV4::Value::undefinedValue();
-    return args[0];
+    return args[0]->v4Value();
 }
 #endif // QT_NO_TRANSLATION
 
@@ -1577,13 +1579,13 @@ v8::Handle<v8::Value> qsTrIdNoOp(const v8::Arguments &args)
 
     \sa QtQuick2::Locale
 */
-v8::Handle<v8::Value> locale(const v8::Arguments &args)
+QV4::Value locale(const v8::Arguments &args)
 {
     QString code;
     if (args.Length() > 1)
-        V8THROW_ERROR("locale() requires 0 or 1 argument");
+        V4THROW_ERROR("locale() requires 0 or 1 argument");
     if (args.Length() == 1 && !args[0]->IsString())
-        V8THROW_TYPE("locale(): argument (locale code) must be a string");
+        V4THROW_TYPE("locale(): argument (locale code) must be a string");
 
     QV8Engine *v8engine = V8ENGINE();
     if (args.Length() == 1)
@@ -1638,17 +1640,17 @@ v8::Handle<v8::Value> locale(const v8::Arguments &args)
 
     \since QtQuick 2.0
 */
-v8::Handle<v8::Value> binding(const v8::Arguments &args)
+QV4::Value binding(const v8::Arguments &args)
 {
     QString code;
     if (args.Length() != 1)
-        V8THROW_ERROR("binding() requires 1 argument");
+        V4THROW_ERROR("binding() requires 1 argument");
     if (!args[0]->IsFunction())
-        V8THROW_TYPE("binding(): argument (binding expression) must be a function");
+        V4THROW_TYPE("binding(): argument (binding expression) must be a function");
 
     v8::Handle<v8::Object> rv = args[0]->ToObject()->Clone();
     rv->SetHiddenValue(v8::Value::fromV4Value(V8ENGINE()->bindingFlagKey()), v8::Boolean::New(true));
-    return rv;
+    return rv->v4Value();
 }
 
 } // namespace QQmlBuiltinFunctions
diff --git a/src/qml/qml/v8/qqmlbuiltinfunctions_p.h b/src/qml/qml/v8/qqmlbuiltinfunctions_p.h
index f73802b136..fb79397921 100644
--- a/src/qml/qml/v8/qqmlbuiltinfunctions_p.h
+++ b/src/qml/qml/v8/qqmlbuiltinfunctions_p.h
@@ -60,57 +60,57 @@ QT_BEGIN_NAMESPACE
 
 namespace QQmlBuiltinFunctions
 {
-v8::Handle<v8::Value> gc(const v8::Arguments &args);
-v8::Handle<v8::Value> consoleError(const v8::Arguments &args);
-v8::Handle<v8::Value> consoleLog(const v8::Arguments &args);
-v8::Handle<v8::Value> consoleProfile(const v8::Arguments &args);
-v8::Handle<v8::Value> consoleProfileEnd(const v8::Arguments &args);
-v8::Handle<v8::Value> consoleTime(const v8::Arguments &args);
-v8::Handle<v8::Value> consoleTimeEnd(const v8::Arguments &args);
-v8::Handle<v8::Value> consoleCount(const v8::Arguments &args);
-v8::Handle<v8::Value> consoleTrace(const v8::Arguments &args);
-v8::Handle<v8::Value> consoleWarn(const v8::Arguments &args);
-v8::Handle<v8::Value> consoleAssert(const v8::Arguments &args);
-v8::Handle<v8::Value> consoleException(const v8::Arguments &args);
-v8::Handle<v8::Value> isQtObject(const v8::Arguments &args);
-v8::Handle<v8::Value> rgba(const v8::Arguments &args);
-v8::Handle<v8::Value> hsla(const v8::Arguments &args);
-v8::Handle<v8::Value> colorEqual(const v8::Arguments &args);
-v8::Handle<v8::Value> font(const v8::Arguments &args);
-v8::Handle<v8::Value> rect(const v8::Arguments &args);
-v8::Handle<v8::Value> point(const v8::Arguments &args);
-v8::Handle<v8::Value> size(const v8::Arguments &args);
-v8::Handle<v8::Value> vector2d(const v8::Arguments &args);
-v8::Handle<v8::Value> vector3d(const v8::Arguments &args);
-v8::Handle<v8::Value> vector4d(const v8::Arguments &args);
-v8::Handle<v8::Value> quaternion(const v8::Arguments &args);
-v8::Handle<v8::Value> matrix4x4(const v8::Arguments &args);
-v8::Handle<v8::Value> lighter(const v8::Arguments &args);
-v8::Handle<v8::Value> darker(const v8::Arguments &args);
-v8::Handle<v8::Value> tint(const v8::Arguments &args);
-v8::Handle<v8::Value> formatDate(const v8::Arguments &args);
-v8::Handle<v8::Value> formatTime(const v8::Arguments &args);
-v8::Handle<v8::Value> formatDateTime(const v8::Arguments &args);
-v8::Handle<v8::Value> openUrlExternally(const v8::Arguments &args);
-v8::Handle<v8::Value> fontFamilies(const v8::Arguments &args);
-v8::Handle<v8::Value> md5(const v8::Arguments &args);
-v8::Handle<v8::Value> btoa(const v8::Arguments &args);
-v8::Handle<v8::Value> atob(const v8::Arguments &args);
-v8::Handle<v8::Value> quit(const v8::Arguments &args);
-v8::Handle<v8::Value> resolvedUrl(const v8::Arguments &args);
-v8::Handle<v8::Value> createQmlObject(const v8::Arguments &args);
-v8::Handle<v8::Value> createComponent(const v8::Arguments &args);
+QV4::Value gc(const v8::Arguments &args);
+QV4::Value consoleError(const v8::Arguments &args);
+QV4::Value consoleLog(const v8::Arguments &args);
+QV4::Value consoleProfile(const v8::Arguments &args);
+QV4::Value consoleProfileEnd(const v8::Arguments &args);
+QV4::Value consoleTime(const v8::Arguments &args);
+QV4::Value consoleTimeEnd(const v8::Arguments &args);
+QV4::Value consoleCount(const v8::Arguments &args);
+QV4::Value consoleTrace(const v8::Arguments &args);
+QV4::Value consoleWarn(const v8::Arguments &args);
+QV4::Value consoleAssert(const v8::Arguments &args);
+QV4::Value consoleException(const v8::Arguments &args);
+QV4::Value isQtObject(const v8::Arguments &args);
+QV4::Value rgba(const v8::Arguments &args);
+QV4::Value hsla(const v8::Arguments &args);
+QV4::Value colorEqual(const v8::Arguments &args);
+QV4::Value font(const v8::Arguments &args);
+QV4::Value rect(const v8::Arguments &args);
+QV4::Value point(const v8::Arguments &args);
+QV4::Value size(const v8::Arguments &args);
+QV4::Value vector2d(const v8::Arguments &args);
+QV4::Value vector3d(const v8::Arguments &args);
+QV4::Value vector4d(const v8::Arguments &args);
+QV4::Value quaternion(const v8::Arguments &args);
+QV4::Value matrix4x4(const v8::Arguments &args);
+QV4::Value lighter(const v8::Arguments &args);
+QV4::Value darker(const v8::Arguments &args);
+QV4::Value tint(const v8::Arguments &args);
+QV4::Value formatDate(const v8::Arguments &args);
+QV4::Value formatTime(const v8::Arguments &args);
+QV4::Value formatDateTime(const v8::Arguments &args);
+QV4::Value openUrlExternally(const v8::Arguments &args);
+QV4::Value fontFamilies(const v8::Arguments &args);
+QV4::Value md5(const v8::Arguments &args);
+QV4::Value btoa(const v8::Arguments &args);
+QV4::Value atob(const v8::Arguments &args);
+QV4::Value quit(const v8::Arguments &args);
+QV4::Value resolvedUrl(const v8::Arguments &args);
+QV4::Value createQmlObject(const v8::Arguments &args);
+QV4::Value createComponent(const v8::Arguments &args);
 #ifndef QT_NO_TRANSLATION
-v8::Handle<v8::Value> qsTranslate(const v8::Arguments &args);
-v8::Handle<v8::Value> qsTranslateNoOp(const v8::Arguments &args);
-v8::Handle<v8::Value> qsTr(const v8::Arguments &args);
-v8::Handle<v8::Value> qsTrNoOp(const v8::Arguments &args);
-v8::Handle<v8::Value> qsTrId(const v8::Arguments &args);
-v8::Handle<v8::Value> qsTrIdNoOp(const v8::Arguments &args);
+QV4::Value qsTranslate(const v8::Arguments &args);
+QV4::Value qsTranslateNoOp(const v8::Arguments &args);
+QV4::Value qsTr(const v8::Arguments &args);
+QV4::Value qsTrNoOp(const v8::Arguments &args);
+QV4::Value qsTrId(const v8::Arguments &args);
+QV4::Value qsTrIdNoOp(const v8::Arguments &args);
 #endif
-v8::Handle<v8::Value> stringArg(const v8::Arguments &args);
-v8::Handle<v8::Value> locale(const v8::Arguments &args);
-v8::Handle<v8::Value> binding(const v8::Arguments &args);
+QV4::Value stringArg(const v8::Arguments &args);
+QV4::Value locale(const v8::Arguments &args);
+QV4::Value binding(const v8::Arguments &args);
 }
 
 QT_END_NAMESPACE
diff --git a/src/qml/qml/v8/qv4domerrors_p.h b/src/qml/qml/v8/qv4domerrors_p.h
index 434f9c5846..3d612cb397 100644
--- a/src/qml/qml/v8/qv4domerrors_p.h
+++ b/src/qml/qml/v8/qv4domerrors_p.h
@@ -83,6 +83,14 @@ QT_BEGIN_NAMESPACE
     return v8::Handle<v8::Value>(); \
 }
 
+#define V4THROW_DOM(error, string) { \
+    QV4::ExecutionContext *ctx = v8::Isolate::GetEngine()->current; \
+    QV4::Value v = QV4::Value::fromString(ctx, QStringLiteral(string)); \
+    QV4::Object *ex = ctx->engine->newErrorObject(v); \
+    ex->put(ctx, ctx->engine->newIdentifier(QStringLiteral("code")), QV4::Value::fromInt32(error)); \
+    ctx->throwError(QV4::Value::fromObject(ex)); \
+}
+
 namespace QV4 {
 struct ExecutionEngine;
 }
diff --git a/src/qml/qml/v8/qv8engine_p.h b/src/qml/qml/v8/qv8engine_p.h
index d8f6e1bb39..db8984ccda 100644
--- a/src/qml/qml/v8/qv8engine_p.h
+++ b/src/qml/qml/v8/qv8engine_p.h
@@ -116,10 +116,17 @@ namespace QV4 {
     v8::ThrowException(v8::Exception::Error(v8::String::New(string))); \
     return v8::Handle<v8::Value>(); \
 }
+
+#define V4THROW_ERROR(string) \
+    v8::Isolate::GetEngine()->current->throwError(QStringLiteral(string));
+
 #define V8THROW_TYPE(string) { \
     v8::ThrowException(v8::Exception::TypeError(v8::String::New(string))); \
     return v8::Handle<v8::Value>(); \
 }
+#define V4THROW_TYPE(string) \
+    v8::Isolate::GetEngine()->current->throwError(QStringLiteral(string));
+
 #define V8ENGINE_ACCESSOR() ((QV8Engine *)v8::External::Cast(info.Data().get())->Value());
 #define V8THROW_ERROR_SETTER(string) { \
     v8::ThrowException(v8::Exception::Error(v8::String::New(string))); \
diff --git a/src/qml/qml/v8/qv8include.cpp b/src/qml/qml/v8/qv8include.cpp
index 92e262157b..72b7868b9b 100644
--- a/src/qml/qml/v8/qv8include.cpp
+++ b/src/qml/qml/v8/qv8include.cpp
@@ -167,7 +167,7 @@ void QV8Include::finished()
 /*
     Documented in qv8engine.cpp
 */
-v8::Handle<v8::Value> QV8Include::include(const v8::Arguments &args)
+QV4::Value QV8Include::include(const v8::Arguments &args)
 {
     if (args.Length() == 0)
         return QV4::Value::undefinedValue();
@@ -176,7 +176,7 @@ v8::Handle<v8::Value> QV8Include::include(const v8::Arguments &args)
     QQmlContextData *context = engine->callingContext();
 
     if (!context || !context->isJSContext) 
-        V8THROW_ERROR("Qt.include(): Can only be called from JavaScript files");
+        V4THROW_ERROR("Qt.include(): Can only be called from JavaScript files");
 
     QUrl url(context->resolvedUrl(QUrl(args[0]->v4Value().toQString())));
     
@@ -237,7 +237,7 @@ v8::Handle<v8::Value> QV8Include::include(const v8::Arguments &args)
     if (result.IsEmpty())
         return QV4::Value::undefinedValue();
     else 
-        return result;
+        return result->v4Value();
 }
 
 QT_END_NAMESPACE
diff --git a/src/qml/qml/v8/qv8include_p.h b/src/qml/qml/v8/qv8include_p.h
index 36a322e33a..ab7b2ff8db 100644
--- a/src/qml/qml/v8/qv8include_p.h
+++ b/src/qml/qml/v8/qv8include_p.h
@@ -78,7 +78,7 @@ public:
         Exception = 3
     };
 
-    static v8::Handle<v8::Value> include(const v8::Arguments &args);
+    static QV4::Value include(const v8::Arguments &args);
 
 private slots:
     void finished();
diff --git a/src/qml/qml/v8/qv8qobjectwrapper.cpp b/src/qml/qml/v8/qv8qobjectwrapper.cpp
index e58584b9ca..aa22156ae3 100644
--- a/src/qml/qml/v8/qv8qobjectwrapper.cpp
+++ b/src/qml/qml/v8/qv8qobjectwrapper.cpp
@@ -133,7 +133,7 @@ struct CallArgument {
 
     inline void initAsType(int type);
     inline void fromValue(int type, QV8Engine *, v8::Handle<v8::Value>);
-    inline v8::Handle<v8::Value> toValue(QV8Engine *);
+    inline QV4::Value toValue(QV8Engine *);
 
 private:
     CallArgument(const CallArgument &);
@@ -1366,10 +1366,10 @@ int QV8QObjectConnectionList::qt_metacall(QMetaObject::Call method, int index, v
     return -1;
 }
 
-v8::Handle<v8::Value> QV8QObjectWrapper::Connect(const v8::Arguments &args)
+QV4::Value QV8QObjectWrapper::Connect(const v8::Arguments &args)
 {
     if (args.Length() == 0)
-        V8THROW_ERROR("Function.prototype.connect: no arguments given");
+        V4THROW_ERROR("Function.prototype.connect: no arguments given");
 
     QV8Engine *engine = V8ENGINE();
 
@@ -1378,13 +1378,13 @@ v8::Handle<v8::Value> QV8QObjectWrapper::Connect(const v8::Arguments &args)
     int signalIndex = signalInfo.second;
 
     if (signalIndex < 0)
-        V8THROW_ERROR("Function.prototype.connect: this object is not a signal");
+        V4THROW_ERROR("Function.prototype.connect: this object is not a signal");
 
     if (!signalObject)
-        V8THROW_ERROR("Function.prototype.connect: cannot connect to deleted QObject");
+        V4THROW_ERROR("Function.prototype.connect: cannot connect to deleted QObject");
 
     if (signalObject->metaObject()->method(signalIndex).methodType() != QMetaMethod::Signal)
-        V8THROW_ERROR("Function.prototype.connect: this object is not a signal");
+        V4THROW_ERROR("Function.prototype.connect: this object is not a signal");
 
     v8::Handle<v8::Value> functionValue;
     v8::Handle<v8::Value> functionThisValue;
@@ -1397,10 +1397,10 @@ v8::Handle<v8::Value> QV8QObjectWrapper::Connect(const v8::Arguments &args)
     }
 
     if (!functionValue->IsFunction())
-        V8THROW_ERROR("Function.prototype.connect: target is not a function");
+        V4THROW_ERROR("Function.prototype.connect: target is not a function");
 
     if (!functionThisValue.IsEmpty() && !functionThisValue->IsObject())
-        V8THROW_ERROR("Function.prototype.connect: target this is not an object");
+        V4THROW_ERROR("Function.prototype.connect: target this is not an object");
 
     QV8QObjectWrapper *qobjectWrapper = engine->qobjectWrapper();
     QHash<QObject *, QV8QObjectConnectionList *> &connections = qobjectWrapper->m_connections;
@@ -1425,10 +1425,10 @@ v8::Handle<v8::Value> QV8QObjectWrapper::Connect(const v8::Arguments &args)
     return QV4::Value::undefinedValue();
 }
 
-v8::Handle<v8::Value> QV8QObjectWrapper::Disconnect(const v8::Arguments &args)
+QV4::Value QV8QObjectWrapper::Disconnect(const v8::Arguments &args)
 {
     if (args.Length() == 0)
-        V8THROW_ERROR("Function.prototype.disconnect: no arguments given");
+        V4THROW_ERROR("Function.prototype.disconnect: no arguments given");
 
     QV8Engine *engine = V8ENGINE();
 
@@ -1437,13 +1437,13 @@ v8::Handle<v8::Value> QV8QObjectWrapper::Disconnect(const v8::Arguments &args)
     int signalIndex = signalInfo.second;
 
     if (signalIndex == -1)
-        V8THROW_ERROR("Function.prototype.disconnect: this object is not a signal");
+        V4THROW_ERROR("Function.prototype.disconnect: this object is not a signal");
 
     if (!signalObject)
-        V8THROW_ERROR("Function.prototype.disconnect: cannot disconnect from deleted QObject");
+        V4THROW_ERROR("Function.prototype.disconnect: cannot disconnect from deleted QObject");
 
     if (signalIndex < 0 || signalObject->metaObject()->method(signalIndex).methodType() != QMetaMethod::Signal)
-        V8THROW_ERROR("Function.prototype.disconnect: this object is not a signal");
+        V4THROW_ERROR("Function.prototype.disconnect: this object is not a signal");
 
     v8::Handle<v8::Value> functionValue;
     v8::Handle<v8::Value> functionThisValue;
@@ -1456,10 +1456,10 @@ v8::Handle<v8::Value> QV8QObjectWrapper::Disconnect(const v8::Arguments &args)
     }
 
     if (!functionValue->IsFunction())
-        V8THROW_ERROR("Function.prototype.disconnect: target is not a function");
+        V4THROW_ERROR("Function.prototype.disconnect: target is not a function");
 
     if (!functionThisValue.IsEmpty() && !functionThisValue->IsObject())
-        V8THROW_ERROR("Function.prototype.disconnect: target this is not an object");
+        V4THROW_ERROR("Function.prototype.disconnect: target this is not an object");
 
     QV8QObjectWrapper *qobjectWrapper = engine->qobjectWrapper();
     QHash<QObject *, QV8QObjectConnectionList *> &connectionsList = qobjectWrapper->m_connections;
@@ -1555,7 +1555,7 @@ private:
 };
 }
 
-static v8::Handle<v8::Value> CallMethod(QObject *object, int index, int returnType, int argCount, 
+static QV4::Value CallMethod(QObject *object, int index, int returnType, int argCount,
                                         int *argTypes, QV8Engine *engine, CallArgs &callArgs)
 {
     if (argCount > 0) {
@@ -1795,7 +1795,7 @@ static const QQmlPropertyData * RelatedMethod(QObject *object,
     }
 }
 
-static v8::Handle<v8::Value> CallPrecise(QObject *object, const QQmlPropertyData &data,
+static QV4::Value CallPrecise(QObject *object, const QQmlPropertyData &data,
                                          QV8Engine *engine, CallArgs &callArgs)
 {
     QByteArray unknownTypeError;
@@ -1805,8 +1805,7 @@ static v8::Handle<v8::Value> CallPrecise(QObject *object, const QQmlPropertyData
     if (returnType == QMetaType::UnknownType) {
         QString typeName = QString::fromLatin1(unknownTypeError);
         QString error = QString::fromLatin1("Unknown method return type: %1").arg(typeName);
-        v8::ThrowException(v8::Exception::Error(engine->toString(error)));
-        return v8::Handle<v8::Value>();
+        QV8Engine::getV4(engine)->current->throwError(error);
     }
 
     if (data.hasArguments()) {
@@ -1820,14 +1819,12 @@ static v8::Handle<v8::Value> CallPrecise(QObject *object, const QQmlPropertyData
         if (!args) {
             QString typeName = QString::fromLatin1(unknownTypeError);
             QString error = QString::fromLatin1("Unknown method parameter type: %1").arg(typeName);
-            v8::ThrowException(v8::Exception::Error(engine->toString(error)));
-            return v8::Handle<v8::Value>();
+            QV8Engine::getV4(engine)->current->throwError(error);
         }
 
         if (args[0] > callArgs.Length()) {
             QString error = QLatin1String("Insufficient arguments");
-            v8::ThrowException(v8::Exception::Error(engine->toString(error)));
-            return v8::Handle<v8::Value>();
+            QV8Engine::getV4(engine)->current->throwError(error);
         }
 
         return CallMethod(object, data.coreIndex, returnType, args[0], args + 1, engine, callArgs);
@@ -1852,7 +1849,7 @@ Resolve the overloaded method to call.  The algorithm works conceptually like th
         If two or more overloads have the same match score, call the last one.  The match
         score is constructed by adding the matchScore() result for each of the parameters.
 */
-static v8::Handle<v8::Value> CallOverloaded(QObject *object, const QQmlPropertyData &data,
+static QV4::Value CallOverloaded(QObject *object, const QQmlPropertyData &data,
                                             QV8Engine *engine, CallArgs &callArgs)
 {
     int argumentCount = callArgs.Length();
@@ -1923,12 +1920,11 @@ static v8::Handle<v8::Value> CallOverloaded(QObject *object, const QQmlPropertyD
             candidate = RelatedMethod(object, candidate, dummy);
         }
 
-        v8::ThrowException(v8::Exception::Error(engine->toString(error)));
-        return v8::Handle<v8::Value>();
+        QV8Engine::getV4(engine)->current->throwError(error);
     }
 }
 
-static v8::Handle<v8::Value> ToString(QV8Engine *engine, QObject *object, int, v8::Handle<v8::Object>)
+static QV4::Value ToString(QV8Engine *engine, QObject *object, int, v8::Handle<v8::Object>)
 {
     QString result;
     if (object) {
@@ -1952,7 +1948,7 @@ static v8::Handle<v8::Value> ToString(QV8Engine *engine, QObject *object, int, v
     return engine->toString(result);
 }
 
-static v8::Handle<v8::Value> Destroy(QV8Engine *, QObject *object, int argCount, v8::Handle<v8::Object> args)
+static QV4::Value Destroy(QV8Engine *, QObject *object, int argCount, v8::Handle<v8::Object> args)
 {
     QQmlData *ddata = QQmlData::get(object, false);
     if (!ddata || ddata->indestructible || ddata->rootObjectInCreation) {
@@ -1973,7 +1969,7 @@ static v8::Handle<v8::Value> Destroy(QV8Engine *, QObject *object, int argCount,
     return QV4::Value::undefinedValue();
 }
 
-v8::Handle<v8::Value> QV8QObjectWrapper::Invoke(const v8::Arguments &args)
+QV4::Value QV8QObjectWrapper::Invoke(const v8::Arguments &args)
 {
     // object, index, qmlglobal, argCount, args
     Q_ASSERT(args.Length() == 5);
@@ -1992,7 +1988,7 @@ v8::Handle<v8::Value> QV8QObjectWrapper::Invoke(const v8::Arguments &args)
         v8::Handle<v8::Array> data = v8::Array::New(2);
         data->Set(0, args[0]);
         data->Set(1, args[1]);
-        return data;
+        return data->v4Value();
     }
 
     QObject *object = resource->object;
@@ -2043,7 +2039,7 @@ v8::Handle<v8::Value> QV8QObjectWrapper::Invoke(const v8::Arguments &args)
         QMetaObject::metacall(object, QMetaObject::InvokeMetaMethod, method.coreIndex, args);
 
         if (rv.IsEmpty()) return QV4::Value::undefinedValue();
-        return rv;
+        return rv->v4Value();
     }
 
     CallArgs callArgs(argCount, &arguments);
@@ -2229,20 +2225,20 @@ void CallArgument::fromValue(int callType, QV8Engine *engine, v8::Handle<v8::Val
     }
 }
 
-v8::Handle<v8::Value> CallArgument::toValue(QV8Engine *engine)
+QV4::Value CallArgument::toValue(QV8Engine *engine)
 {
     if (type == qMetaTypeId<QJSValue>()) {
-        return v8::Value::fromV4Value(QJSValuePrivate::get(*qjsValuePtr)->getValue(QV8Engine::getV4(engine)));
+        return QJSValuePrivate::get(*qjsValuePtr)->getValue(QV8Engine::getV4(engine));
     } else if (type == QMetaType::Int) {
-        return v8::Integer::New(int(intValue));
+        return QV4::Value::fromInt32(int(intValue));
     } else if (type == QMetaType::UInt) {
-        return v8::Integer::NewFromUnsigned(intValue);
+        return QV4::Value::fromUInt32(intValue);
     } else if (type == QMetaType::Bool) {
-        return v8::Boolean::New(boolValue);
+        return QV4::Value::fromBoolean(boolValue);
     } else if (type == QMetaType::Double) {
-        return v8::Number::New(doubleValue);
+        return QV4::Value::fromDouble(doubleValue);
     } else if (type == QMetaType::Float) {
-        return v8::Number::New(floatValue);
+        return QV4::Value::fromDouble(floatValue);
     } else if (type == QMetaType::QString) {
         return engine->toString(*qstringPtr);
     } else if (type == QMetaType::QObjectStar) {
@@ -2254,22 +2250,23 @@ v8::Handle<v8::Value> CallArgument::toValue(QV8Engine *engine)
         // XXX Can this be made more by using Array as a prototype and implementing
         // directly against QList<QObject*>?
         QList<QObject *> &list = *qlistPtr;
-        v8::Handle<v8::Array> array = v8::Array::New(list.count());
+        QV4::ArrayObject *array = QV8Engine::getV4(engine)->newArrayObject();
+        array->setArrayLength(list.count());
         for (int ii = 0; ii < list.count(); ++ii) 
-            array->Set(ii, engine->newQObject(list.at(ii)));
-        return array;
+            array->arrayData[ii].value = engine->newQObject(list.at(ii));
+        return QV4::Value::fromObject(array);
     } else if (type == qMetaTypeId<QQmlV4Handle>()) {
-        return handlePtr->toV8Handle();
+        return handlePtr->toValue();
     } else if (type == QMetaType::QJsonArray) {
-        return v8::Value::fromV4Value(engine->jsonArrayToJS(*jsonArrayPtr));
+        return engine->jsonArrayToJS(*jsonArrayPtr);
     } else if (type == QMetaType::QJsonObject) {
-        return v8::Value::fromV4Value(engine->jsonObjectToJS(*jsonObjectPtr));
+        return engine->jsonObjectToJS(*jsonObjectPtr);
     } else if (type == QMetaType::QJsonValue) {
-        return v8::Value::fromV4Value(engine->jsonValueToJS(*jsonValuePtr));
+        return engine->jsonValueToJS(*jsonValuePtr);
     } else if (type == -1 || type == qMetaTypeId<QVariant>()) {
         QVariant value = *qvariantPtr;
-        v8::Handle<v8::Value> rv = engine->fromVariant(value);
-        if (QObject *object = engine->toQObject(rv->v4Value()))
+        QV4::Value rv = engine->fromVariant(value);
+        if (QObject *object = engine->toQObject(rv))
             QQmlData::get(object, true)->setImplicitDestructible();
         return rv;
     } else {
diff --git a/src/qml/qml/v8/qv8qobjectwrapper_p.h b/src/qml/qml/v8/qv8qobjectwrapper_p.h
index b0358cc1a7..0dd4b7f85b 100644
--- a/src/qml/qml/v8/qv8qobjectwrapper_p.h
+++ b/src/qml/qml/v8/qv8qobjectwrapper_p.h
@@ -132,9 +132,9 @@ private:
     static v8::Handle<v8::Integer> Query(v8::Handle<v8::String> property,
                                          const v8::AccessorInfo &info);
     static v8::Handle<v8::Array> Enumerator(const v8::AccessorInfo &info);
-    static v8::Handle<v8::Value> Connect(const v8::Arguments &args);
-    static v8::Handle<v8::Value> Disconnect(const v8::Arguments &args);
-    static v8::Handle<v8::Value> Invoke(const v8::Arguments &args);
+    static QV4::Value Connect(const v8::Arguments &args);
+    static QV4::Value Disconnect(const v8::Arguments &args);
+    static QV4::Value Invoke(const v8::Arguments &args);
     static QPair<QObject *, int> ExtractQtMethod(QV8Engine *, v8::Handle<v8::Function>);
     static QPair<QObject *, int> ExtractQtSignal(QV8Engine *, v8::Handle<v8::Object>);
     static void WeakQObjectReferenceCallback(v8::Persistent<v8::Value> handle, void *wrapper);
diff --git a/src/qml/qml/v8/qv8sequencewrapper.cpp b/src/qml/qml/v8/qv8sequencewrapper.cpp
index 3f72697d9a..c4579fd73c 100644
--- a/src/qml/qml/v8/qv8sequencewrapper.cpp
+++ b/src/qml/qml/v8/qv8sequencewrapper.cpp
@@ -265,7 +265,7 @@ v8::Handle<v8::Value> QV8SequenceWrapper::SortGetter(v8::Handle<v8::String> prop
     return info.Data();
 }
 
-v8::Handle<v8::Value> QV8SequenceWrapper::Sort(const v8::Arguments &args)
+QV4::Value QV8SequenceWrapper::Sort(const v8::Arguments &args)
 {
     int argCount = args.Length();
 
@@ -283,24 +283,24 @@ v8::Handle<v8::Value> QV8SequenceWrapper::Sort(const v8::Arguments &args)
         }
     }
 
-    return args.This();
+    return args.This()->v4Value();
 }
 
-v8::Handle<v8::Value> QV8SequenceWrapper::ToString(const v8::Arguments &args)
+QV4::Value QV8SequenceWrapper::ToString(const v8::Arguments &args)
 {
     QV8SequenceResource *sr = v8_resource_cast<QV8SequenceResource>(args.This());
     Q_ASSERT(sr);
     return sr->toString();
 }
 
-v8::Handle<v8::Value> QV8SequenceWrapper::ValueOf(const v8::Arguments &args)
+QV4::Value QV8SequenceWrapper::ValueOf(const v8::Arguments &args)
 {
     QV8SequenceResource *sr = v8_resource_cast<QV8SequenceResource>(args.This());
     Q_ASSERT(sr);
-    v8::Handle<v8::Value> tostringValue = sr->toString();
-    if (!tostringValue.IsEmpty())
+    QV4::Value tostringValue = sr->toString();
+    if (!tostringValue.isUndefined())
         return tostringValue;
-    return v8::Integer::NewFromUnsigned(sr->lengthGetter());
+    return QV4::Value::fromUInt32(sr->lengthGetter());
 }
 
 v8::Handle<v8::Value> QV8SequenceWrapper::Getter(v8::Handle<v8::String> property,
diff --git a/src/qml/qml/v8/qv8sequencewrapper_p.h b/src/qml/qml/v8/qv8sequencewrapper_p.h
index e63d7af8c4..2408e4a2ae 100644
--- a/src/qml/qml/v8/qv8sequencewrapper_p.h
+++ b/src/qml/qml/v8/qv8sequencewrapper_p.h
@@ -99,13 +99,13 @@ private:
     static v8::Handle<v8::Value> LengthGetter(v8::Handle<v8::String> property, const v8::AccessorInfo &info);
     static void LengthSetter(v8::Handle<v8::String> property, v8::Handle<v8::Value> value, const v8::AccessorInfo &info);
     static v8::Handle<v8::Value> ToStringGetter(v8::Handle<v8::String> property, const v8::AccessorInfo &info);
-    static v8::Handle<v8::Value> ToString(const v8::Arguments &args);
+    static QV4::Value ToString(const v8::Arguments &args);
     static v8::Handle<v8::Value> ValueOfGetter(v8::Handle<v8::String> property, const v8::AccessorInfo &info);
     static v8::Handle<v8::Value> SortGetter(v8::Handle<v8::String> property, const v8::AccessorInfo &info);
-    static v8::Handle<v8::Value> ValueOf(const v8::Arguments &args);
+    static QV4::Value ValueOf(const v8::Arguments &args);
     static v8::Handle<v8::Value> Getter(v8::Handle<v8::String> property, const v8::AccessorInfo &info);
     static v8::Handle<v8::Value> Setter(v8::Handle<v8::String> property, v8::Handle<v8::Value> value, const v8::AccessorInfo &info);
-    static v8::Handle<v8::Value> Sort(const v8::Arguments &args);
+    static QV4::Value Sort(const v8::Arguments &args);
 };
 
 
diff --git a/src/qml/qml/v8/qv8sequencewrapper_p_p.h b/src/qml/qml/v8/qv8sequencewrapper_p_p.h
index c8d61422e5..0924d106cd 100644
--- a/src/qml/qml/v8/qv8sequencewrapper_p_p.h
+++ b/src/qml/qml/v8/qv8sequencewrapper_p_p.h
@@ -87,7 +87,7 @@ public:
     virtual v8::Handle<v8::Value> indexedGetter(quint32 index) = 0;
     virtual v8::Handle<v8::Boolean> indexedDeleter(quint32 index) = 0;
     virtual v8::Handle<v8::Array> indexedEnumerator() = 0;
-    virtual v8::Handle<v8::Value> toString() = 0;
+    virtual QV4::Value toString() = 0;
     virtual void sort(v8::Handle<v8::Function> comparer) = 0;
 
     ObjectType objectType;
@@ -443,7 +443,7 @@ static QString convertUrlToString(QV8Engine *, const QUrl &v)
                 } \
                 return retn; \
             } \
-            v8::Handle<v8::Value> toString() \
+            QV4::Value toString() \
             { \
                 if (objectType == QV8SequenceResource::Reference) { \
                     if (!object) \
diff --git a/src/qml/qml/v8/qv8valuetypewrapper.cpp b/src/qml/qml/v8/qv8valuetypewrapper.cpp
index 1bc2c4b4a7..2215c99241 100644
--- a/src/qml/qml/v8/qv8valuetypewrapper.cpp
+++ b/src/qml/qml/v8/qv8valuetypewrapper.cpp
@@ -254,7 +254,7 @@ v8::Handle<v8::Value> QV8ValueTypeWrapper::ToStringGetter(v8::Handle<v8::String>
     return info.Data();
 }
 
-v8::Handle<v8::Value> QV8ValueTypeWrapper::ToString(const v8::Arguments &args)
+QV4::Value QV8ValueTypeWrapper::ToString(const v8::Arguments &args)
 {
     QV8ValueTypeResource *resource = v8_resource_cast<QV8ValueTypeResource>(args.This());
     if (resource) {
diff --git a/src/qml/qml/v8/qv8valuetypewrapper_p.h b/src/qml/qml/v8/qv8valuetypewrapper_p.h
index 620f0bbc78..132ae1ad9c 100644
--- a/src/qml/qml/v8/qv8valuetypewrapper_p.h
+++ b/src/qml/qml/v8/qv8valuetypewrapper_p.h
@@ -87,7 +87,7 @@ public:
 private:
     static v8::Handle<v8::Value> ToStringGetter(v8::Handle<v8::String> property,
                                                 const v8::AccessorInfo &info);
-    static v8::Handle<v8::Value> ToString(const v8::Arguments &args);
+    static QV4::Value ToString(const v8::Arguments &args);
     static v8::Handle<v8::Value> Getter(v8::Handle<v8::String> property,
                                         const v8::AccessorInfo &info);
     static v8::Handle<v8::Value> Setter(v8::Handle<v8::String> property,
diff --git a/src/qml/qml/v8/qv8variantwrapper.cpp b/src/qml/qml/v8/qv8variantwrapper.cpp
index c2c5988e0e..ffff9e4fd4 100644
--- a/src/qml/qml/v8/qv8variantwrapper.cpp
+++ b/src/qml/qml/v8/qv8variantwrapper.cpp
@@ -221,7 +221,7 @@ v8::Handle<v8::Value> QV8VariantWrapper::ValueOfGetter(v8::Handle<v8::String> pr
     return info.Data();
 }
 
-v8::Handle<v8::Value> QV8VariantWrapper::Preserve(const v8::Arguments &args)
+QV4::Value QV8VariantWrapper::Preserve(const v8::Arguments &args)
 {
     QV8VariantResource *resource = v8_resource_cast<QV8VariantResource>(args.This());
     if (resource) {
@@ -230,7 +230,7 @@ v8::Handle<v8::Value> QV8VariantWrapper::Preserve(const v8::Arguments &args)
     return QV4::Value::undefinedValue();
 }
 
-v8::Handle<v8::Value> QV8VariantWrapper::Destroy(const v8::Arguments &args)
+QV4::Value QV8VariantWrapper::Destroy(const v8::Arguments &args)
 {
     QV8VariantResource *resource = v8_resource_cast<QV8VariantResource>(args.This());
     if (resource) {
@@ -240,7 +240,7 @@ v8::Handle<v8::Value> QV8VariantWrapper::Destroy(const v8::Arguments &args)
     return QV4::Value::undefinedValue();
 }
 
-v8::Handle<v8::Value> QV8VariantWrapper::ToString(const v8::Arguments &args)
+QV4::Value QV8VariantWrapper::ToString(const v8::Arguments &args)
 {
     QV8VariantResource *resource = v8_resource_cast<QV8VariantResource>(args.This());
     if (resource) {
@@ -253,7 +253,7 @@ v8::Handle<v8::Value> QV8VariantWrapper::ToString(const v8::Arguments &args)
     }
 }
 
-v8::Handle<v8::Value> QV8VariantWrapper::ValueOf(const v8::Arguments &args)
+QV4::Value QV8VariantWrapper::ValueOf(const v8::Arguments &args)
 {
     QV8VariantResource *resource = v8_resource_cast<QV8VariantResource>(args.This());
     if (resource) {
@@ -266,14 +266,14 @@ v8::Handle<v8::Value> QV8VariantWrapper::ValueOf(const v8::Arguments &args)
         case QVariant::Int:
         case QVariant::Double:
         case QVariant::UInt:
-            return v8::Number::New(v.toDouble());
+            return QV4::Value::fromDouble(v.toDouble());
         case QVariant::Bool:
-            return v8::Boolean::New(v.toBool());
+            return QV4::Value::fromBoolean(v.toBool());
         default:
             break;
         }
     }
-    return args.This();
+    return args.This()->v4Value();
 }
 
 QT_END_NAMESPACE
diff --git a/src/qml/qml/v8/qv8variantwrapper_p.h b/src/qml/qml/v8/qv8variantwrapper_p.h
index 125875ab24..a25d4917fc 100644
--- a/src/qml/qml/v8/qv8variantwrapper_p.h
+++ b/src/qml/qml/v8/qv8variantwrapper_p.h
@@ -90,10 +90,10 @@ private:
                                                 const v8::AccessorInfo &info);
     static v8::Handle<v8::Value> ValueOfGetter(v8::Handle<v8::String> property,
                                                const v8::AccessorInfo &info);
-    static v8::Handle<v8::Value> Preserve(const v8::Arguments &args);
-    static v8::Handle<v8::Value> Destroy(const v8::Arguments &args);
-    static v8::Handle<v8::Value> ToString(const v8::Arguments &args);
-    static v8::Handle<v8::Value> ValueOf(const v8::Arguments &args);
+    static QV4::Value Preserve(const v8::Arguments &args);
+    static QV4::Value Destroy(const v8::Arguments &args);
+    static QV4::Value ToString(const v8::Arguments &args);
+    static QV4::Value ValueOf(const v8::Arguments &args);
 
     QV8Engine *m_engine;
     v8::Persistent<v8::Function> m_constructor;
diff --git a/src/qml/types/qquickworkerscript.cpp b/src/qml/types/qquickworkerscript.cpp
index 3eb1461d5c..62a125de74 100644
--- a/src/qml/types/qquickworkerscript.cpp
+++ b/src/qml/types/qquickworkerscript.cpp
@@ -175,7 +175,7 @@ public:
 
     int m_nextId;
 
-    static v8::Handle<v8::Value> sendMessage(const v8::Arguments &args);
+    static QV4::Value sendMessage(const v8::Arguments &args);
 
 signals:
     void stopThread();
@@ -272,7 +272,7 @@ QQuickWorkerScriptEnginePrivate::QQuickWorkerScriptEnginePrivate(QQmlEngine *eng
 {
 }
 
-v8::Handle<v8::Value> QQuickWorkerScriptEnginePrivate::sendMessage(const v8::Arguments &args)
+QV4::Value QQuickWorkerScriptEnginePrivate::sendMessage(const v8::Arguments &args)
 {
     WorkerEngine *engine = (WorkerEngine*)V8ENGINE();
 
diff --git a/src/quick/items/context2d/qquickcontext2d.cpp b/src/quick/items/context2d/qquickcontext2d.cpp
index 8bf44a2077..196394f253 100644
--- a/src/quick/items/context2d/qquickcontext2d.cpp
+++ b/src/quick/items/context2d/qquickcontext2d.cpp
@@ -60,6 +60,7 @@
 
 #include <qqmlengine.h>
 #include <private/qv4domerrors_p.h>
+#include <private/qv4engine_p.h>
 #include <QtCore/qnumeric.h>
 #include <private/qquickwindow_p.h>
 
@@ -114,7 +115,7 @@ static const double Q_PI   = 3.14159265358979323846;   // pi
 #define DEGREES(t) ((t) * 180.0 / Q_PI)
 
 #define CHECK_CONTEXT(r)     if (!r || !r->context || !r->context->bufferValid()) \
-                                V8THROW_ERROR("Not a Context2D object");
+                                V4THROW_ERROR("Not a Context2D object");
 
 #define CHECK_CONTEXT_SETTER(r)     if (!r || !r->context || !r->context->bufferValid()) \
                                        V8THROW_ERROR_SETTER("Not a Context2D object");
@@ -422,7 +423,7 @@ static QString qt_composite_mode_to_string(QPainter::CompositionMode op)
 }
 
 
-static v8::Handle<v8::Object> qt_create_image_data(qreal w, qreal h, QV8Engine* engine, const QImage& image)
+static QV4::Value qt_create_image_data(qreal w, qreal h, QV8Engine* engine, const QImage& image)
 {
     QQuickContext2DEngineData *ed = engineData(engine);
     v8::Handle<v8::Object> imageData = ed->constructorImageData->NewInstance();
@@ -438,7 +439,7 @@ static v8::Handle<v8::Object> qt_create_image_data(qreal w, qreal h, QV8Engine*
     pixelData->SetExternalResource(r);
 
     imageData->SetInternalField(0, pixelData);
-    return imageData;
+    return imageData->v4Value();
 }
 
 //static script functions
@@ -466,27 +467,27 @@ static v8::Handle<v8::Value> ctx2d_canvas(v8::Handle<v8::String>, const v8::Acce
 
     \sa save()
 */
-static v8::Handle<v8::Value> ctx2d_restore(const v8::Arguments &args)
+static QV4::Value ctx2d_restore(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
 
     r->context->popState();
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
     \qmlmethod object QtQuick2::Context2D::reset()
     Resets the context state and properties to the default values.
 */
-static v8::Handle<v8::Value> ctx2d_reset(const v8::Arguments &args)
+static QV4::Value ctx2d_reset(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
 
     r->context->reset();
 
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -519,14 +520,14 @@ static v8::Handle<v8::Value> ctx2d_reset(const v8::Arguments &args)
     The current path is NOT part of the drawing state. The path can be reset by
     invoking the beginPath() method.
 */
-static v8::Handle<v8::Value> ctx2d_save(const v8::Arguments &args)
+static QV4::Value ctx2d_save(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
 
     r->context->pushState();
 
-    return args.This();
+    return args.ThisV4();
 }
 
 // transformations
@@ -545,14 +546,14 @@ static v8::Handle<v8::Value> ctx2d_save(const v8::Arguments &args)
     where the \c angle of rotation is in radians.
 
 */
-static v8::Handle<v8::Value> ctx2d_rotate(const v8::Arguments &args)
+static QV4::Value ctx2d_rotate(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
 
     if (args.Length() == 1)
         r->context->rotate(args[0]->NumberValue());
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -569,7 +570,7 @@ static v8::Handle<v8::Value> ctx2d_rotate(const v8::Arguments &args)
     \image qml-item-canvas-scale.png
 
 */
-static v8::Handle<v8::Value> ctx2d_scale(const v8::Arguments &args)
+static QV4::Value ctx2d_scale(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -577,7 +578,7 @@ static v8::Handle<v8::Value> ctx2d_scale(const v8::Arguments &args)
 
     if (args.Length() == 2)
         r->context->scale(args[0]->NumberValue(), args[1]->NumberValue());
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -613,7 +614,7 @@ static v8::Handle<v8::Value> ctx2d_scale(const v8::Arguments &args)
 
     \sa transform()
 */
-static v8::Handle<v8::Value> ctx2d_setTransform(const v8::Arguments &args)
+static QV4::Value ctx2d_setTransform(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -627,7 +628,7 @@ static v8::Handle<v8::Value> ctx2d_setTransform(const v8::Arguments &args)
                                                         , args[4]->NumberValue()
                                                         , args[5]->NumberValue());
 
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -640,7 +641,7 @@ static v8::Handle<v8::Value> ctx2d_setTransform(const v8::Arguments &args)
 
     \sa setTransform()
 */
-static v8::Handle<v8::Value> ctx2d_transform(const v8::Arguments &args)
+static QV4::Value ctx2d_transform(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -654,7 +655,7 @@ static v8::Handle<v8::Value> ctx2d_transform(const v8::Arguments &args)
                                                   , args[4]->NumberValue()
                                                   , args[5]->NumberValue());
 
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -666,7 +667,7 @@ static v8::Handle<v8::Value> ctx2d_transform(const v8::Arguments &args)
     Translating the origin enables you to draw patterns of different objects on the canvas
     without having to measure the coordinates manually for each shape.
 */
-static v8::Handle<v8::Value> ctx2d_translate(const v8::Arguments &args)
+static QV4::Value ctx2d_translate(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -674,7 +675,7 @@ static v8::Handle<v8::Value> ctx2d_translate(const v8::Arguments &args)
 
     if (args.Length() == 2)
             r->context->translate(args[0]->NumberValue(), args[1]->NumberValue());
-    return args.This();
+    return args.ThisV4();
 }
 
 
@@ -684,14 +685,14 @@ static v8::Handle<v8::Value> ctx2d_translate(const v8::Arguments &args)
 
     \sa transform(), setTransform(), reset()
 */
-static v8::Handle<v8::Value> ctx2d_resetTransform(const v8::Arguments &args)
+static QV4::Value ctx2d_resetTransform(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
 
     r->context->setTransform(1, 0, 0, 1, 0, 0);
 
-    return args.This();
+    return args.ThisV4();
 }
 
 
@@ -699,7 +700,7 @@ static v8::Handle<v8::Value> ctx2d_resetTransform(const v8::Arguments &args)
     \qmlmethod object QtQuick2::Context2D::shear(real sh, real sv )
     Shear the transformation matrix with \a sh in horizontal direction and \a sv in vertical direction.
 */
-static v8::Handle<v8::Value> ctx2d_shear(const v8::Arguments &args)
+static QV4::Value ctx2d_shear(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -707,7 +708,7 @@ static v8::Handle<v8::Value> ctx2d_shear(const v8::Arguments &args)
     if (args.Length() == 2)
             r->context->shear(args[0]->NumberValue(), args[1]->NumberValue());
 
-    return args.This();
+    return args.ThisV4();
 }
 // compositing
 
@@ -992,7 +993,7 @@ static void ctx2d_strokeStyle_set(v8::Handle<v8::String>, v8::Handle<v8::Value>
     \sa strokeStyle
   */
 
-static v8::Handle<v8::Value> ctx2d_createLinearGradient(const v8::Arguments &args)
+static QV4::Value ctx2d_createLinearGradient(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -1014,15 +1015,15 @@ static v8::Handle<v8::Value> ctx2d_createLinearGradient(const v8::Arguments &arg
          || !qIsFinite(x1)
          || !qIsFinite(y1)) {
             delete r;
-            V8THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "createLinearGradient(): Incorrect arguments")
+            V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "createLinearGradient(): Incorrect arguments")
         }
 
         r->brush = QLinearGradient(x0, y0, x1, y1);
         gradient->SetExternalResource(r);
-        return gradient;
+        return gradient->v4Value();
     }
 
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -1038,7 +1039,7 @@ static v8::Handle<v8::Value> ctx2d_createLinearGradient(const v8::Arguments &arg
     \sa strokeStyle
   */
 
-static v8::Handle<v8::Value> ctx2d_createRadialGradient(const v8::Arguments &args)
+static QV4::Value ctx2d_createRadialGradient(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -1065,19 +1066,19 @@ static v8::Handle<v8::Value> ctx2d_createRadialGradient(const v8::Arguments &arg
          || !qIsFinite(r1)
          || !qIsFinite(y1)) {
             delete r;
-            V8THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "createRadialGradient(): Incorrect arguments")
+            V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "createRadialGradient(): Incorrect arguments")
         }
 
         if (r0 < 0 || r1 < 0)
-            V8THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "createRadialGradient(): Incorrect arguments")
+            V4THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "createRadialGradient(): Incorrect arguments")
 
 
         r->brush = QRadialGradient(QPointF(x1, y1), r0+r1, QPointF(x0, y0));
         gradient->SetExternalResource(r);
-        return gradient;
+        return gradient->v4Value();
     }
 
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -1093,7 +1094,7 @@ static v8::Handle<v8::Value> ctx2d_createRadialGradient(const v8::Arguments &arg
     \sa strokeStyle
   */
 
-static v8::Handle<v8::Value> ctx2d_createConicalGradient(const v8::Arguments &args)
+static QV4::Value ctx2d_createConicalGradient(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -1111,20 +1112,20 @@ static v8::Handle<v8::Value> ctx2d_createConicalGradient(const v8::Arguments &ar
         qreal angle = DEGREES(args[2]->NumberValue());
         if (!qIsFinite(x) || !qIsFinite(y)) {
             delete r;
-            V8THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "createConicalGradient(): Incorrect arguments");
+            V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "createConicalGradient(): Incorrect arguments");
         }
 
         if (!qIsFinite(angle)) {
             delete r;
-            V8THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "createConicalGradient(): Incorrect arguments");
+            V4THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "createConicalGradient(): Incorrect arguments");
         }
 
         r->brush = QConicalGradient(x, y, angle);
         gradient->SetExternalResource(r);
-        return gradient;
+        return gradient->v4Value();
     }
 
-    return args.This();
+    return args.ThisV4();
 }
 /*!
   \qmlmethod variant QtQuick2::Context2D::createPattern(color color, enumeration patternMode)
@@ -1169,7 +1170,7 @@ static v8::Handle<v8::Value> ctx2d_createConicalGradient(const v8::Arguments &ar
   \sa strokeStyle
   \sa fillStyle
   */
-static v8::Handle<v8::Value> ctx2d_createPattern(const v8::Arguments &args)
+static QV4::Value ctx2d_createPattern(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -1224,7 +1225,7 @@ static v8::Handle<v8::Value> ctx2d_createPattern(const v8::Arguments &args)
 
         v8::Handle<v8::Object> pattern = ed->constructorPattern->NewInstance();
         pattern->SetExternalResource(styleResouce);
-        return pattern;
+        return pattern->v4Value();
 
     }
     return QV4::Value::undefinedValue();
@@ -1531,7 +1532,7 @@ static void ctx2d_path_set(v8::Handle<v8::String>, v8::Handle<v8::Value> value,
   \qmlmethod object QtQuick2::Context2D::clearRect(real x, real y, real w, real h)
   Clears all pixels on the canvas in the given rectangle to transparent black.
   */
-static v8::Handle<v8::Value> ctx2d_clearRect(const v8::Arguments &args)
+static QV4::Value ctx2d_clearRect(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -1543,7 +1544,7 @@ static v8::Handle<v8::Value> ctx2d_clearRect(const v8::Arguments &args)
                               args[2]->NumberValue(),
                               args[3]->NumberValue());
 
-    return args.This();
+    return args.ThisV4();
 }
 /*!
   \qmlmethod object QtQuick2::Context2D::fillRect(real x, real y, real w, real h)
@@ -1551,14 +1552,14 @@ static v8::Handle<v8::Value> ctx2d_clearRect(const v8::Arguments &args)
 
    \sa fillStyle
   */
-static v8::Handle<v8::Value> ctx2d_fillRect(const v8::Arguments &args)
+static QV4::Value ctx2d_fillRect(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
 
     if (args.Length() == 4)
         r->context->fillRect(args[0]->NumberValue(), args[1]->NumberValue(), args[2]->NumberValue(), args[3]->NumberValue());
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -1571,7 +1572,7 @@ static v8::Handle<v8::Value> ctx2d_fillRect(const v8::Arguments &args)
    \sa lineJoin
    \sa miterLimit
   */
-static v8::Handle<v8::Value> ctx2d_strokeRect(const v8::Arguments &args)
+static QV4::Value ctx2d_strokeRect(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -1579,7 +1580,7 @@ static v8::Handle<v8::Value> ctx2d_strokeRect(const v8::Arguments &args)
     if (args.Length() == 4)
         r->context->strokeRect(args[0]->NumberValue(), args[1]->NumberValue(), args[2]->NumberValue(), args[3]->NumberValue());
 
-    return args.This();
+    return args.ThisV4();
 }
 
 // Complex shapes (paths) API
@@ -1590,7 +1591,7 @@ static v8::Handle<v8::Value> ctx2d_strokeRect(const v8::Arguments &args)
   \sa arcTo,
       {http://www.w3.org/TR/2dcontext/#dom-context-2d-arc}{W3C 2d context standard for arc}
   */
-static v8::Handle<v8::Value> ctx2d_arc(const v8::Arguments &args)
+static QV4::Value ctx2d_arc(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -1604,7 +1605,7 @@ static v8::Handle<v8::Value> ctx2d_arc(const v8::Arguments &args)
         qreal radius = args[2]->NumberValue();
 
         if (qIsFinite(radius) && radius < 0)
-           V8THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "Incorrect argument radius");
+           V4THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "Incorrect argument radius");
 
         r->context->arc(args[0]->NumberValue(),
                         args[1]->NumberValue(),
@@ -1614,7 +1615,7 @@ static v8::Handle<v8::Value> ctx2d_arc(const v8::Arguments &args)
                         antiClockwise);
     }
 
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -1637,7 +1638,7 @@ static v8::Handle<v8::Value> ctx2d_arc(const v8::Arguments &args)
   \sa arc, {http://www.w3.org/TR/2dcontext/#dom-context-2d-arcto}{W3C 2d
       context standard for arcTo}
   */
-static v8::Handle<v8::Value> ctx2d_arcTo(const v8::Arguments &args)
+static QV4::Value ctx2d_arcTo(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -1646,7 +1647,7 @@ static v8::Handle<v8::Value> ctx2d_arcTo(const v8::Arguments &args)
         qreal radius = args[4]->NumberValue();
 
         if (qIsFinite(radius) && radius < 0)
-           V8THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "Incorrect argument radius");
+           V4THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "Incorrect argument radius");
 
         r->context->arcTo(args[0]->NumberValue(),
                           args[1]->NumberValue(),
@@ -1655,7 +1656,7 @@ static v8::Handle<v8::Value> ctx2d_arcTo(const v8::Arguments &args)
                           radius);
     }
 
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -1663,7 +1664,7 @@ static v8::Handle<v8::Value> ctx2d_arcTo(const v8::Arguments &args)
 
    Resets the current path to a new path.
   */
-static v8::Handle<v8::Value> ctx2d_beginPath(const v8::Arguments &args)
+static QV4::Value ctx2d_beginPath(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -1671,7 +1672,7 @@ static v8::Handle<v8::Value> ctx2d_beginPath(const v8::Arguments &args)
 
     r->context->beginPath();
 
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -1693,7 +1694,7 @@ static v8::Handle<v8::Value> ctx2d_beginPath(const v8::Arguments &args)
   \sa {http://www.w3.org/TR/2dcontext/#dom-context-2d-beziercurveto}{W3C 2d context standard for bezierCurveTo}
   \sa {http://www.openrise.com/lab/FlowerPower/}{The beautiful flower demo by using bezierCurveTo}
   */
-static v8::Handle<v8::Value> ctx2d_bezierCurveTo(const v8::Arguments &args)
+static QV4::Value ctx2d_bezierCurveTo(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -1708,12 +1709,12 @@ static v8::Handle<v8::Value> ctx2d_bezierCurveTo(const v8::Arguments &args)
         qreal y = args[5]->NumberValue();
 
         if (!qIsFinite(cp1x) || !qIsFinite(cp1y) || !qIsFinite(cp2x) || !qIsFinite(cp2y) || !qIsFinite(x) || !qIsFinite(y))
-            return args.This();
+            return args.ThisV4();
 
         r->context->bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y);
     }
 
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -1740,13 +1741,13 @@ static v8::Handle<v8::Value> ctx2d_bezierCurveTo(const v8::Arguments &args)
     \sa fill()
    \sa {http://www.w3.org/TR/2dcontext/#dom-context-2d-clip}{W3C 2d context standard for clip}
   */
-static v8::Handle<v8::Value> ctx2d_clip(const v8::Arguments &args)
+static QV4::Value ctx2d_clip(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
 
     r->context->clip();
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -1756,7 +1757,7 @@ static v8::Handle<v8::Value> ctx2d_clip(const v8::Arguments &args)
 
    \sa {http://www.w3.org/TR/2dcontext/#dom-context-2d-closepath}{W3C 2d context standard for closePath}
   */
-static v8::Handle<v8::Value> ctx2d_closePath(const v8::Arguments &args)
+static QV4::Value ctx2d_closePath(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -1764,7 +1765,7 @@ static v8::Handle<v8::Value> ctx2d_closePath(const v8::Arguments &args)
 
     r->context->closePath();
 
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -1776,12 +1777,12 @@ static v8::Handle<v8::Value> ctx2d_closePath(const v8::Arguments &args)
 
    \sa fillStyle
   */
-static v8::Handle<v8::Value> ctx2d_fill(const v8::Arguments &args)
+static QV4::Value ctx2d_fill(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r);
     r->context->fill();
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -1789,7 +1790,7 @@ static v8::Handle<v8::Value> ctx2d_fill(const v8::Arguments &args)
 
    Draws a line from the current position to the point (x, y).
  */
-static v8::Handle<v8::Value> ctx2d_lineTo(const v8::Arguments &args)
+static QV4::Value ctx2d_lineTo(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -1800,12 +1801,12 @@ static v8::Handle<v8::Value> ctx2d_lineTo(const v8::Arguments &args)
         qreal y = args[1]->NumberValue();
 
         if (!qIsFinite(x) || !qIsFinite(y))
-            return args.This();
+            return args.ThisV4();
 
         r->context->lineTo(x, y);
     }
 
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -1813,7 +1814,7 @@ static v8::Handle<v8::Value> ctx2d_lineTo(const v8::Arguments &args)
 
    Creates a new subpath with the given point.
  */
-static v8::Handle<v8::Value> ctx2d_moveTo(const v8::Arguments &args)
+static QV4::Value ctx2d_moveTo(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -1823,10 +1824,10 @@ static v8::Handle<v8::Value> ctx2d_moveTo(const v8::Arguments &args)
         qreal y = args[1]->NumberValue();
 
         if (!qIsFinite(x) || !qIsFinite(y))
-            return args.This();
+            return args.ThisV4();
         r->context->moveTo(x, y);
     }
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -1836,7 +1837,7 @@ static v8::Handle<v8::Value> ctx2d_moveTo(const v8::Arguments &args)
 
    See \l{http://www.w3.org/TR/2dcontext/#dom-context-2d-quadraticcurveto}{W3C 2d context standard for  for quadraticCurveTo}
  */
-static v8::Handle<v8::Value> ctx2d_quadraticCurveTo(const v8::Arguments &args)
+static QV4::Value ctx2d_quadraticCurveTo(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -1848,12 +1849,12 @@ static v8::Handle<v8::Value> ctx2d_quadraticCurveTo(const v8::Arguments &args)
         qreal y = args[3]->NumberValue();
 
         if (!qIsFinite(cpx) || !qIsFinite(cpy) || !qIsFinite(x) || !qIsFinite(y))
-            return args.This();
+            return args.ThisV4();
 
         r->context->quadraticCurveTo(cpx, cpy, x, y);
     }
 
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -1861,14 +1862,14 @@ static v8::Handle<v8::Value> ctx2d_quadraticCurveTo(const v8::Arguments &args)
 
    Adds a rectangle at position (\c x, \c y), with the given width \c w and height \c h, as a closed subpath.
  */
-static v8::Handle<v8::Value> ctx2d_rect(const v8::Arguments &args)
+static QV4::Value ctx2d_rect(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
 
     if (args.Length() == 4)
         r->context->rect(args[0]->NumberValue(), args[1]->NumberValue(), args[2]->NumberValue(), args[3]->NumberValue());
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -1877,7 +1878,7 @@ static v8::Handle<v8::Value> ctx2d_rect(const v8::Arguments &args)
    Adds the given rectangle rect with rounded corners to the path. The \c xRadius and \c yRadius arguments specify the radius of the
    ellipses defining the corners of the rounded rectangle.
  */
-static v8::Handle<v8::Value> ctx2d_roundedRect(const v8::Arguments &args)
+static QV4::Value ctx2d_roundedRect(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -1889,7 +1890,7 @@ static v8::Handle<v8::Value> ctx2d_roundedRect(const v8::Arguments &args)
                               , args[3]->NumberValue()
                               , args[4]->NumberValue()
                               , args[5]->NumberValue());
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -1900,7 +1901,7 @@ static v8::Handle<v8::Value> ctx2d_roundedRect(const v8::Arguments &args)
 
   The ellipse is composed of a clockwise curve, starting and finishing at zero degrees (the 3 o'clock position).
  */
-static v8::Handle<v8::Value> ctx2d_ellipse(const v8::Arguments &args)
+static QV4::Value ctx2d_ellipse(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -1909,7 +1910,7 @@ static v8::Handle<v8::Value> ctx2d_ellipse(const v8::Arguments &args)
     if (args.Length() == 4)
         r->context->ellipse(args[0]->NumberValue(), args[1]->NumberValue(), args[2]->NumberValue(), args[3]->NumberValue());
 
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -1918,7 +1919,7 @@ static v8::Handle<v8::Value> ctx2d_ellipse(const v8::Arguments &args)
   Adds the given \c text to the path as a set of closed subpaths created from the current context font supplied.
   The subpaths are positioned so that the left end of the text's baseline lies at the point specified by (\c x, \c y).
  */
-static v8::Handle<v8::Value> ctx2d_text(const v8::Arguments &args)
+static QV4::Value ctx2d_text(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -1928,10 +1929,10 @@ static v8::Handle<v8::Value> ctx2d_text(const v8::Arguments &args)
         qreal y = args[2]->NumberValue();
 
         if (!qIsFinite(x) || !qIsFinite(y))
-            return args.This();
+            return args.ThisV4();
         r->context->text(args[0]->v4Value().toQString(), x, y);
     }
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -1943,13 +1944,13 @@ static v8::Handle<v8::Value> ctx2d_text(const v8::Arguments &args)
 
    \sa strokeStyle
   */
-static v8::Handle<v8::Value> ctx2d_stroke(const v8::Arguments &args)
+static QV4::Value ctx2d_stroke(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
 
     r->context->stroke();
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -1959,7 +1960,7 @@ static v8::Handle<v8::Value> ctx2d_stroke(const v8::Arguments &args)
 
    \sa {http://www.w3.org/TR/2dcontext/#dom-context-2d-ispointinpath}{W3C 2d context standard for isPointInPath}
   */
-static v8::Handle<v8::Value> ctx2d_isPointInPath(const v8::Arguments &args)
+static QV4::Value ctx2d_isPointInPath(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -1967,28 +1968,28 @@ static v8::Handle<v8::Value> ctx2d_isPointInPath(const v8::Arguments &args)
     bool pointInPath = false;
     if (args.Length() == 2)
         pointInPath = r->context->isPointInPath(args[0]->NumberValue(), args[1]->NumberValue());
-    return v8::Boolean::New(pointInPath);
+    return QV4::Value::fromBoolean(pointInPath);
 }
 
-static v8::Handle<v8::Value> ctx2d_drawFocusRing(const v8::Arguments &args)
+static QV4::Value ctx2d_drawFocusRing(const v8::Arguments &args)
 {
     Q_UNUSED(args);
 
-    V8THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "Context2D::drawFocusRing is not supported");
+    V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "Context2D::drawFocusRing is not supported");
 }
 
-static v8::Handle<v8::Value> ctx2d_setCaretSelectionRect(const v8::Arguments &args)
+static QV4::Value ctx2d_setCaretSelectionRect(const v8::Arguments &args)
 {
     Q_UNUSED(args);
 
-    V8THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "Context2D::setCaretSelectionRect is not supported");
+    V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "Context2D::setCaretSelectionRect is not supported");
 }
 
-static v8::Handle<v8::Value> ctx2d_caretBlinkRate(const v8::Arguments &args)
+static QV4::Value ctx2d_caretBlinkRate(const v8::Arguments &args)
 {
     Q_UNUSED(args);
 
-    V8THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "Context2D::caretBlinkRate is not supported");
+    V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "Context2D::caretBlinkRate is not supported");
 }
 // text
 /*!
@@ -2153,7 +2154,7 @@ static void ctx2d_textBaseline_set(v8::Handle<v8::String>, v8::Handle<v8::Value>
   \sa textBaseline
   \sa strokeText
   */
-static v8::Handle<v8::Value> ctx2d_fillText(const v8::Arguments &args)
+static QV4::Value ctx2d_fillText(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -2162,11 +2163,11 @@ static v8::Handle<v8::Value> ctx2d_fillText(const v8::Arguments &args)
         qreal x = args[1]->NumberValue();
         qreal y = args[2]->NumberValue();
         if (!qIsFinite(x) || !qIsFinite(y))
-            return args.This();
+            return args.ThisV4();
         QPainterPath textPath = r->context->createTextGlyphs(x, y, args[0]->v4Value().toQString());
         r->context->buffer()->fill(textPath);
     }
-    return args.This();
+    return args.ThisV4();
 }
 /*!
   \qmlmethod object QtQuick2::Context2D::strokeText(text, x, y)
@@ -2176,14 +2177,14 @@ static v8::Handle<v8::Value> ctx2d_fillText(const v8::Arguments &args)
   \sa textBaseline
   \sa fillText
   */
-static v8::Handle<v8::Value> ctx2d_strokeText(const v8::Arguments &args)
+static QV4::Value ctx2d_strokeText(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
 
     if (args.Length() == 3)
         r->context->drawText(args[0]->v4Value().toQString(), args[1]->NumberValue(), args[2]->NumberValue(), false);
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -2210,7 +2211,7 @@ static v8::Handle<v8::Value> ctx2d_strokeText(const v8::Arguments &args)
   \qmlmethod variant QtQuick2::Context2D::measureText(text)
   Returns a TextMetrics object with the metrics of the given text in the current font.
   */
-static v8::Handle<v8::Value> ctx2d_measureText(const v8::Arguments &args)
+static QV4::Value ctx2d_measureText(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -2218,9 +2219,9 @@ static v8::Handle<v8::Value> ctx2d_measureText(const v8::Arguments &args)
     if (args.Length() == 1) {
         QFontMetrics fm(r->context->state.font);
         uint width = fm.width(args[0]->v4Value().toQString());
-        v8::Handle<v8::Object> tm = v8::Object::New();
-        tm->Set(v8::String::New("width"), v8::Number::New(width));
-        return tm;
+        QV4::Object *tm = v8::Isolate::GetEngine()->newObject();
+        tm->put(v8::Isolate::GetEngine()->current, v8::Isolate::GetEngine()->newIdentifier(QStringLiteral("width")), QV4::Value::fromDouble(width));
+        return QV4::Value::fromObject(tm);
     }
     return QV4::Value::undefinedValue();
 }
@@ -2284,7 +2285,7 @@ static v8::Handle<v8::Value> ctx2d_measureText(const v8::Arguments &args)
 
   \sa {http://www.w3.org/TR/2dcontext/#dom-context-2d-drawimage}{W3C 2d context standard for drawImage}
 */
-static v8::Handle<v8::Value> ctx2d_drawImage(const v8::Arguments &args)
+static QV4::Value ctx2d_drawImage(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -2293,18 +2294,18 @@ static v8::Handle<v8::Value> ctx2d_drawImage(const v8::Arguments &args)
     qreal sx, sy, sw, sh, dx, dy, dw, dh;
 
     if (!args.Length())
-        return args.This();
+        return args.ThisV4();
 
     //FIXME:This function should be moved to QQuickContext2D::drawImage(...)
     if (!r->context->state.invertibleCTM)
-        return args.This();
+        return args.ThisV4();
 
     QQmlRefPointer<QQuickCanvasPixmap> pixmap;
 
     if (args[0]->IsString()) {
         QUrl url(args[0]->v4Value().toQString());
         if (!url.isValid())
-            V8THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "drawImage(), type mismatch");
+            V4THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "drawImage(), type mismatch");
 
         pixmap = r->context->createPixmap(url);
     } else if (args[0]->IsObject()) {
@@ -2321,14 +2322,14 @@ static v8::Handle<v8::Value> ctx2d_drawImage(const v8::Arguments &args)
             if (!img.isNull())
                 pixmap.take(new QQuickCanvasPixmap(img, canvas->window()));
         } else {
-            V8THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "drawImage(), type mismatch");
+            V4THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "drawImage(), type mismatch");
         }
     } else {
-        V8THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "drawImage(), type mismatch");
+        V4THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "drawImage(), type mismatch");
     }
 
     if (pixmap.isNull() || !pixmap->isValid())
-        return args.This();
+        return args.ThisV4();
 
     if (args.Length() == 3) {
         dx = args[1]->NumberValue();
@@ -2358,7 +2359,7 @@ static v8::Handle<v8::Value> ctx2d_drawImage(const v8::Arguments &args)
         dw = args[7]->NumberValue();
         dh = args[8]->NumberValue();
     } else {
-        return args.This();
+        return args.ThisV4();
     }
 
     if (!qIsFinite(sx)
@@ -2369,7 +2370,7 @@ static v8::Handle<v8::Value> ctx2d_drawImage(const v8::Arguments &args)
      || !qIsFinite(dy)
      || !qIsFinite(dw)
      || !qIsFinite(dh))
-        return args.This();
+        return args.ThisV4();
 
     if (sx < 0
     || sy < 0
@@ -2378,12 +2379,12 @@ static v8::Handle<v8::Value> ctx2d_drawImage(const v8::Arguments &args)
     || sx + sw > pixmap->width()
     || sy + sh > pixmap->height()
     || sx + sw < 0 || sy + sh < 0) {
-            V8THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "drawImage(), index size error");
+            V4THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "drawImage(), index size error");
     }
 
     r->context->buffer()->drawPixmap(pixmap, QRectF(sx, sy, sw, sh), QRectF(dx, dy, dw, dh));
 
-    return args.This();
+    return args.ThisV4();
 }
 
 // pixel manipulation
@@ -2535,7 +2536,7 @@ v8::Handle<v8::Value> ctx2d_pixelArray_indexed_set(uint32_t index, v8::Handle<v8
 
    \sa Canvas::loadImage(), QtQuick2::Canvas::unloadImage(), QtQuick2::Canvas::isImageLoaded
   */
-static v8::Handle<v8::Value> ctx2d_createImageData(const v8::Arguments &args)
+static QV4::Value ctx2d_createImageData(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -2560,12 +2561,12 @@ static v8::Handle<v8::Value> ctx2d_createImageData(const v8::Arguments &args)
         qreal h = args[1]->NumberValue();
 
         if (!qIsFinite(w) || !qIsFinite(h))
-            V8THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "createImageData(): invalid arguments");
+            V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "createImageData(): invalid arguments");
 
         if (w > 0 && h > 0)
             return qt_create_image_data(w, h, engine, QImage());
         else
-            V8THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "createImageData(): invalid arguments");
+            V4THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "createImageData(): invalid arguments");
     }
     return QV4::Value::undefinedValue();
 }
@@ -2574,7 +2575,7 @@ static v8::Handle<v8::Value> ctx2d_createImageData(const v8::Arguments &args)
   \qmlmethod CanvasImageData QtQuick2::Canvas::getImageData(real sx, real sy, real sw, real sh)
   Returns an CanvasImageData object containing the image data for the given rectangle of the canvas.
   */
-static v8::Handle<v8::Value> ctx2d_getImageData(const v8::Arguments &args)
+static QV4::Value ctx2d_getImageData(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -2586,13 +2587,13 @@ static v8::Handle<v8::Value> ctx2d_getImageData(const v8::Arguments &args)
         qreal w = args[2]->NumberValue();
         qreal h = args[3]->NumberValue();
         if (!qIsFinite(x) || !qIsFinite(y) || !qIsFinite(w) || !qIsFinite(w))
-            V8THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "getImageData(): Invalid arguments");
+            V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "getImageData(): Invalid arguments");
 
         if (w <= 0 || h <= 0)
-            V8THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "getImageData(): Invalid arguments");
+            V4THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "getImageData(): Invalid arguments");
 
         QImage image = r->context->canvas()->toImage(QRectF(x, y, w, h));
-        v8::Handle<v8::Object> imageData = qt_create_image_data(w, h, engine, image);
+        QV4::Value imageData = qt_create_image_data(w, h, engine, image);
 
         return imageData;
     }
@@ -2603,7 +2604,7 @@ static v8::Handle<v8::Value> ctx2d_getImageData(const v8::Arguments &args)
   \qmlmethod object QtQuick2::Context2D::putImageData(CanvasImageData imageData, real dx, real dy, real dirtyX, real dirtyY, real dirtyWidth, real dirtyHeight)
   Paints the data from the given ImageData object onto the canvas. If a dirty rectangle (\a dirtyX, \a dirtyY, \a dirtyWidth, \a dirtyHeight) is provided, only the pixels from that rectangle are painted.
   */
-static v8::Handle<v8::Value> ctx2d_putImageData(const v8::Arguments &args)
+static QV4::Value ctx2d_putImageData(const v8::Arguments &args)
 {
     QV8Context2DResource *r = v8_resource_cast<QV8Context2DResource>(args.This());
     CHECK_CONTEXT(r)
@@ -2611,14 +2612,14 @@ static v8::Handle<v8::Value> ctx2d_putImageData(const v8::Arguments &args)
         return QV4::Value::undefinedValue();
 
     if (args[0]->IsNull() || !args[0]->IsObject()) {
-        V8THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "Context2D::putImageData, the image data type mismatch");
+        V4THROW_DOM(DOMEXCEPTION_TYPE_MISMATCH_ERR, "Context2D::putImageData, the image data type mismatch");
     }
     qreal dx = args[1]->NumberValue();
     qreal dy = args[2]->NumberValue();
     qreal w, h, dirtyX, dirtyY, dirtyWidth, dirtyHeight;
 
     if (!qIsFinite(dx) || !qIsFinite(dy))
-        V8THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "putImageData() : Invalid arguments");
+        V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "putImageData() : Invalid arguments");
 
     v8::Handle<v8::Object> imageData = args[0]->ToObject();
     QV8Context2DPixelArrayResource *pixelArray = v8_resource_cast<QV8Context2DPixelArrayResource>(imageData->Get(v8::String::New("data"))->ToObject());
@@ -2633,7 +2634,7 @@ static v8::Handle<v8::Value> ctx2d_putImageData(const v8::Arguments &args)
             dirtyHeight = args[6]->NumberValue();
 
             if (!qIsFinite(dirtyX) || !qIsFinite(dirtyY) || !qIsFinite(dirtyWidth) || !qIsFinite(dirtyHeight))
-                V8THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "putImageData() : Invalid arguments");
+                V4THROW_DOM(DOMEXCEPTION_NOT_SUPPORTED_ERR, "putImageData() : Invalid arguments");
 
 
             if (dirtyWidth < 0) {
@@ -2665,7 +2666,7 @@ static v8::Handle<v8::Value> ctx2d_putImageData(const v8::Arguments &args)
             }
 
             if (dirtyWidth <=0 || dirtyHeight <= 0)
-                return args.This();
+                return args.ThisV4();
         } else {
             dirtyX = 0;
             dirtyY = 0;
@@ -2676,7 +2677,7 @@ static v8::Handle<v8::Value> ctx2d_putImageData(const v8::Arguments &args)
         QImage image = pixelArray->image.copy(dirtyX, dirtyY, dirtyWidth, dirtyHeight);
         r->context->buffer()->drawImage(image, QRectF(dirtyX, dirtyY, dirtyWidth, dirtyHeight), QRectF(dx, dy, dirtyWidth, dirtyHeight));
     }
-    return args.This();
+    return args.ThisV4();
 }
 
 /*!
@@ -2699,18 +2700,18 @@ static v8::Handle<v8::Value> ctx2d_putImageData(const v8::Arguments &args)
   gradient.addColorStop(0.7, 'rgba(0, 255, 255, 1');
   \endcode
   */
-static v8::Handle<v8::Value> ctx2d_gradient_addColorStop(const v8::Arguments &args)
+static QV4::Value ctx2d_gradient_addColorStop(const v8::Arguments &args)
 {
     QV8Context2DStyleResource *style = v8_resource_cast<QV8Context2DStyleResource>(args.This());
     if (!style)
-        V8THROW_ERROR("Not a CanvasGradient object");
+        V4THROW_ERROR("Not a CanvasGradient object");
 
     QV8Engine *engine = V8ENGINE();
 
     if (args.Length() == 2) {
 
         if (!style->brush.gradient())
-            V8THROW_ERROR("Not a valid CanvasGradient object, can't get the gradient information");
+            V4THROW_ERROR("Not a valid CanvasGradient object, can't get the gradient information");
         QGradient gradient = *(style->brush.gradient());
         qreal pos = args[0]->NumberValue();
         QColor color;
@@ -2721,18 +2722,18 @@ static v8::Handle<v8::Value> ctx2d_gradient_addColorStop(const v8::Arguments &ar
             color = qt_color_from_string(args[1]);
         }
         if (pos < 0.0 || pos > 1.0 || !qIsFinite(pos)) {
-            V8THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "CanvasGradient: parameter offset out of range");
+            V4THROW_DOM(DOMEXCEPTION_INDEX_SIZE_ERR, "CanvasGradient: parameter offset out of range");
         }
 
         if (color.isValid()) {
             gradient.setColorAt(pos, color);
         } else {
-            V8THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "CanvasGradient: parameter color is not a valid color string");
+            V4THROW_DOM(DOMEXCEPTION_SYNTAX_ERR, "CanvasGradient: parameter color is not a valid color string");
         }
         style->brush = gradient;
     }
 
-    return args.This();
+    return args.ThisV4();
 }
 
 void QQuickContext2D::scale(qreal x,  qreal y)