Remove v8engine dependency from qv4serialize.*

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

diff --git a/src/qml/jsruntime/qv4serialize.cpp b/src/qml/jsruntime/qv4serialize.cpp
index 0ca1b45..9d558d8 100644 (file)
--- a/src/qml/jsruntime/qv4serialize.cpp
+++ b/src/qml/jsruntime/qv4serialize.cpp
@@ -139,10 +139,9 @@ static inline void *popPtr(const char *&data)
 // serialization/deserialization failures
 
 #define ALIGN(size) (((size) + 3) & ~3)
-void Serialize::serialize(QByteArray &data, const QV4::ValueRef v, QV8Engine *engine)
+void Serialize::serialize(QByteArray &data, const QV4::ValueRef v, ExecutionEngine *engine)
 {
-    QV4::ExecutionEngine *v4 = QV8Engine::getV4(engine);
-    QV4::Scope scope(v4);
+    QV4::Scope scope(engine);
 
     if (v->isEmpty()) {
         Q_ASSERT(!"Serialize: got empty value");
@@ -239,7 +238,7 @@ void Serialize::serialize(QByteArray &data, const QV4::ValueRef v, QV8Engine *en
         ScopedObject o(scope, v);
         if (o->isListType()) {
             // valid sequence.  we generate a length (sequence length + 1 for the sequence type)
-            uint seqLength = ScopedValue(scope, o->get(v4->id_length))->toUInt32();
+            uint seqLength = ScopedValue(scope, o->get(engine->id_length))->toUInt32();
             uint length = seqLength + 1;
             if (length > 0xFFFFFF) {
                 push(data, valueheader(WorkerUndefined));
@@ -257,7 +256,7 @@ void Serialize::serialize(QByteArray &data, const QV4::ValueRef v, QV8Engine *en
 
         // regular object
         QV4::ScopedValue val(scope, *v);
-        QV4::ScopedArrayObject properties(scope, QV4::ObjectPrototype::getOwnPropertyNames(v4, val));
+        QV4::ScopedArrayObject properties(scope, QV4::ObjectPrototype::getOwnPropertyNames(engine, val));
         quint32 length = properties->getLength();
         if (length > 0xFFFFFF) {
             push(data, valueheader(WorkerUndefined));
@@ -284,13 +283,12 @@ void Serialize::serialize(QByteArray &data, const QV4::ValueRef v, QV8Engine *en
     }
 }
 
-ReturnedValue Serialize::deserialize(const char *&data, QV8Engine *engine)
+ReturnedValue Serialize::deserialize(const char *&data, ExecutionEngine *engine)
 {
     quint32 header = popUint32(data);
     Type type = headertype(header);
 
-    QV4::ExecutionEngine *v4 = QV8Engine::getV4(engine);
-    Scope scope(v4);
+    Scope scope(engine);
 
     switch (type) {
     case WorkerUndefined:
@@ -306,7 +304,7 @@ ReturnedValue Serialize::deserialize(const char *&data, QV8Engine *engine)
         quint32 size = headersize(header);
         QString qstr((QChar *)data, size);
         data += ALIGN(size * sizeof(quint16));
-        return QV4::Encode(v4->newString(qstr));
+        return QV4::Encode(engine->newString(qstr));
     }
     case WorkerFunction:
         Q_ASSERT(!"Unreachable");
@@ -314,7 +312,7 @@ ReturnedValue Serialize::deserialize(const char *&data, QV8Engine *engine)
     case WorkerArray:
     {
         quint32 size = headersize(header);
-        Scoped<ArrayObject> a(scope, v4->newArrayObject());
+        Scoped<ArrayObject> a(scope, engine->newArrayObject());
         ScopedValue v(scope);
         for (quint32 ii = 0; ii < size; ++ii) {
             v = deserialize(data, engine);
@@ -325,7 +323,7 @@ ReturnedValue Serialize::deserialize(const char *&data, QV8Engine *engine)
     case WorkerObject:
     {
         quint32 size = headersize(header);
-        Scoped<Object> o(scope, v4->newObject());
+        Scoped<Object> o(scope, engine->newObject());
         ScopedValue name(scope);
         ScopedString n(scope);
         ScopedValue value(scope);
@@ -344,29 +342,29 @@ ReturnedValue Serialize::deserialize(const char *&data, QV8Engine *engine)
     case WorkerNumber:
         return QV4::Encode(popDouble(data));
     case WorkerDate:
-        return QV4::Encode(v4->newDateObject(QV4::Primitive::fromDouble(popDouble(data))));
+        return QV4::Encode(engine->newDateObject(QV4::Primitive::fromDouble(popDouble(data))));
     case WorkerRegexp:
     {
         quint32 flags = headersize(header);
         quint32 length = popUint32(data);
         QString pattern = QString((QChar *)data, length - 1);
         data += ALIGN(length * sizeof(quint16));
-        return Encode(v4->newRegExpObject(pattern, flags));
+        return Encode(engine->newRegExpObject(pattern, flags));
     }
     case WorkerListModel:
     {
         void *ptr = popPtr(data);
         QQmlListModelWorkerAgent *agent = (QQmlListModelWorkerAgent *)ptr;
-        QV4::ScopedValue rv(scope, QV4::QObjectWrapper::wrap(v4, agent));
+        QV4::ScopedValue rv(scope, QV4::QObjectWrapper::wrap(engine, agent));
         // ### Find a better solution then the ugly property
         QQmlListModelWorkerAgent::VariantRef ref(agent);
         QVariant var = qVariantFromValue(ref);
-        QV4::ScopedValue v(scope, engine->fromVariant((var)));
-        QV4::ScopedString s(scope, v4->newString(QStringLiteral("__qml:hidden:ref")));
+        QV4::ScopedValue v(scope, engine->v8Engine->fromVariant((var)));
+        QV4::ScopedString s(scope, engine->newString(QStringLiteral("__qml:hidden:ref")));
         rv->asObject()->defineReadonlyProperty(s, v);
 
         agent->release();
-        agent->setV8Engine(engine);
+        agent->setV8Engine(engine->v8Engine);
         return rv.asReturnedValue();
     }
     case WorkerSequence:
@@ -377,7 +375,7 @@ ReturnedValue Serialize::deserialize(const char *&data, QV8Engine *engine)
         quint32 seqLength = length - 1;
         value = deserialize(data, engine);
         int sequenceType = value->integerValue();
-        Scoped<ArrayObject> array(scope, v4->newArrayObject());
+        Scoped<ArrayObject> array(scope, engine->newArrayObject());
         array->arrayReserve(seqLength);
         for (quint32 ii = 0; ii < seqLength; ++ii) {
             value = deserialize(data, engine);
@@ -385,21 +383,21 @@ ReturnedValue Serialize::deserialize(const char *&data, QV8Engine *engine)
         }
         array->setArrayLengthUnchecked(seqLength);
         QVariant seqVariant = QV4::SequencePrototype::toVariant(array, sequenceType, &succeeded);
-        return QV4::SequencePrototype::fromVariant(v4, seqVariant, &succeeded);
+        return QV4::SequencePrototype::fromVariant(engine, seqVariant, &succeeded);
     }
     }
     Q_ASSERT(!"Unreachable");
     return QV4::Encode::undefined();
 }
 
-QByteArray Serialize::serialize(const QV4::ValueRef value, QV8Engine *engine)
+QByteArray Serialize::serialize(const QV4::ValueRef value, ExecutionEngine *engine)
 {
     QByteArray rv;
     serialize(rv, value, engine);
     return rv;
 }
 
-ReturnedValue Serialize::deserialize(const QByteArray &data, QV8Engine *engine)
+ReturnedValue Serialize::deserialize(const QByteArray &data, ExecutionEngine *engine)
 {
     const char *stream = data.constData();
     return deserialize(stream, engine);

diff --git a/src/qml/jsruntime/qv4serialize_p.h b/src/qml/jsruntime/qv4serialize_p.h
index f46c30c..8cab3d5 100644 (file)
--- a/src/qml/jsruntime/qv4serialize_p.h
+++ b/src/qml/jsruntime/qv4serialize_p.h
@@ -57,12 +57,12 @@ namespace QV4 {
 class Serialize {
 public:
 
-    static QByteArray serialize(const ValueRef, QV8Engine *);
-    static ReturnedValue deserialize(const QByteArray &, QV8Engine *);
+    static QByteArray serialize(const ValueRef, ExecutionEngine *);
+    static ReturnedValue deserialize(const QByteArray &, ExecutionEngine *);
 
 private:
-    static void serialize(QByteArray &, const ValueRef, QV8Engine *);
-    static ReturnedValue deserialize(const char *&, QV8Engine *);
+    static void serialize(QByteArray &, const ValueRef, ExecutionEngine *);
+    static ReturnedValue deserialize(const char *&, ExecutionEngine *);
 };
 
 }

diff --git a/src/qml/types/qquickworkerscript.cpp b/src/qml/types/qquickworkerscript.cpp
index ae494f1..931da96 100644 (file)
--- a/src/qml/types/qquickworkerscript.cpp
+++ b/src/qml/types/qquickworkerscript.cpp
@@ -281,7 +281,7 @@ QV4::ReturnedValue QQuickWorkerScriptEnginePrivate::method_sendMessage(QV4::Call
 
     QV4::Scope scope(ctx);
     QV4::ScopedValue v(scope, ctx->d()->callData->argument(2));
-    QByteArray data = QV4::Serialize::serialize(v, engine);
+    QByteArray data = QV4::Serialize::serialize(v, scope.engine);
 
     QMutexLocker locker(&engine->p->m_lock);
     WorkerScript *script = engine->p->workers.value(id);
@@ -353,7 +353,7 @@ void QQuickWorkerScriptEnginePrivate::processMessage(int id, const QByteArray &d
     QV4::Scope scope(v4);
     QV4::ScopedFunctionObject f(scope, workerEngine->onmessage.value());
 
-    QV4::ScopedValue value(scope, QV4::Serialize::deserialize(data, workerEngine));
+    QV4::ScopedValue value(scope, QV4::Serialize::deserialize(data, v4));
 
     QV4::ScopedCallData callData(scope, 2);
     callData->thisObject = workerEngine->global();
@@ -682,7 +682,7 @@ void QQuickWorkerScript::sendMessage(QQmlV4Function *args)
     if (args->length() != 0)
         argument = (*args)[0];
 
-    m_engine->sendMessage(m_scriptId, QV4::Serialize::serialize(argument, args->engine()));
+    m_engine->sendMessage(m_scriptId, QV4::Serialize::serialize(argument, scope.engine));
 }
 
 void QQuickWorkerScript::classBegin()
@@ -734,7 +734,7 @@ bool QQuickWorkerScript::event(QEvent *event)
             WorkerDataEvent *workerEvent = static_cast<WorkerDataEvent *>(event);
             QV8Engine *v8engine = QQmlEnginePrivate::get(engine)->v8engine();
             QV4::Scope scope(QV8Engine::getV4(v8engine));
-            QV4::ScopedValue value(scope, QV4::Serialize::deserialize(workerEvent->data(), v8engine));
+            QV4::ScopedValue value(scope, QV4::Serialize::deserialize(workerEvent->data(), scope.engine));
             emit message(QQmlV4Handle(value));
         }
         return true;