Remove some more QV4::Value usages

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

6 files changed, 44 insertions, 39 deletions

diff --git a/src/qml/jsruntime/qv4sequenceobject.cpp b/src/qml/jsruntime/qv4sequenceobject.cpp
index 5c3204d5fc..f9e1c400e1 100644
--- a/src/qml/jsruntime/qv4sequenceobject.cpp
+++ b/src/qml/jsruntime/qv4sequenceobject.cpp
@@ -347,25 +347,25 @@ public:
 
     struct CompareFunctor
     {
-        CompareFunctor(QV4::ExecutionContext *ctx, const QV4::Value &compareFn)
+        CompareFunctor(QV4::ExecutionContext *ctx, const QV4::ValueRef compareFn)
             : m_ctx(ctx), m_compareFn(compareFn)
         {}
 
         bool operator()(typename Container::value_type lhs, typename Container::value_type rhs)
         {
-            QV4::Managed *fun = this->m_compareFn.asManaged();
-            Scope scope(fun->engine());
+            QV4::Scope scope(m_ctx);
+            ScopedObject compare(scope, m_compareFn);
             ScopedCallData callData(scope, 2);
             callData->args[0] = convertElementToValue(this->m_ctx->engine, lhs);
             callData->args[1] = convertElementToValue(this->m_ctx->engine, rhs);
-            callData->thisObject = QV4::Value::fromObject(this->m_ctx->engine->globalObject);
-            QV4::ScopedValue result(scope, fun->call(callData));
+            callData->thisObject = this->m_ctx->engine->globalObject;
+            QV4::ScopedValue result(scope, compare->call(callData));
             return result->toNumber() < 0;
         }
 
     private:
         QV4::ExecutionContext *m_ctx;
-        QV4::Value m_compareFn;
+        QV4::ValueRef m_compareFn;
     };
 
     void sort(QV4::SimpleCallContext *ctx)
@@ -376,9 +376,9 @@ public:
             loadReference();
         }
 
+        QV4::Scope scope(ctx);
         if (ctx->callData->argc == 1 && ctx->callData->args[0].asFunctionObject()) {
-            QV4::Value compareFn = ctx->callData->args[0];
-            CompareFunctor cf(ctx, compareFn);
+            CompareFunctor cf(ctx, ctx->callData->args[0]);
             std::sort(m_container.begin(), m_container.end(), cf);
         } else {
             DefaultCompareFunctor cf;
@@ -648,7 +648,7 @@ QVariant SequencePrototype::toVariant(const QV4::ValueRef array, int typeHint, b
         return qMetaTypeId<SequenceType>(); \
     } else
 
-int SequencePrototype::metaTypeForSequence(QV4::Object *object)
+int SequencePrototype::metaTypeForSequence(QV4::ObjectRef object)
 {
     FOREACH_QML_SEQUENCE_TYPE(MAP_META_TYPE)
     /*else*/ {
diff --git a/src/qml/jsruntime/qv4sequenceobject_p.h b/src/qml/jsruntime/qv4sequenceobject_p.h
index 5399d2abc5..d2a7054425 100644
--- a/src/qml/jsruntime/qv4sequenceobject_p.h
+++ b/src/qml/jsruntime/qv4sequenceobject_p.h
@@ -79,7 +79,7 @@ struct SequencePrototype : public QV4::Object
     static bool isSequenceType(int sequenceTypeId);
     static ReturnedValue newSequence(QV4::ExecutionEngine *engine, int sequenceTypeId, QObject *object, int propertyIndex, bool *succeeded);
     static ReturnedValue fromVariant(QV4::ExecutionEngine *engine, const QVariant& v, bool *succeeded);
-    static int metaTypeForSequence(QV4::Object *object);
+    static int metaTypeForSequence(ObjectRef object);
     static QVariant toVariant(QV4::Object *object);
     static QVariant toVariant(const ValueRef array, int typeHint, bool *succeeded);
 };
diff --git a/src/qml/jsruntime/qv4serialize.cpp b/src/qml/jsruntime/qv4serialize.cpp
index 86e60e3c76..f775a44858 100644
--- a/src/qml/jsruntime/qv4serialize.cpp
+++ b/src/qml/jsruntime/qv4serialize.cpp
@@ -147,21 +147,21 @@ static inline void *popPtr(const char *&data)
 // serialization/deserialization failures
 
 #define ALIGN(size) (((size) + 3) & ~3)
-void Serialize::serialize(QByteArray &data, const QV4::Value &v, QV8Engine *engine)
+void Serialize::serialize(QByteArray &data, const QV4::ValueRef v, QV8Engine *engine)
 {
     QV4::ExecutionEngine *v4 = QV8Engine::getV4(engine);
     QV4::Scope scope(v4);
 
-    if (v.isEmpty()) {
+    if (v->isEmpty()) {
         Q_ASSERT(!"Serialize: got empty value");
-    } else if (v.isUndefined()) {
+    } else if (v->isUndefined()) {
         push(data, valueheader(WorkerUndefined));
-    } else if (v.isNull()) {
+    } else if (v->isNull()) {
         push(data, valueheader(WorkerNull));
-    } else if (v.isBoolean()) {
-        push(data, valueheader(v.booleanValue() == true ? WorkerTrue : WorkerFalse));
-    } else if (QV4::String *s = v.asString()) {
-        const QString &qstr = s->toQString();
+    } else if (v->isBoolean()) {
+        push(data, valueheader(v->booleanValue() == true ? WorkerTrue : WorkerFalse));
+    } else if (v->isString()) {
+        const QString &qstr = v->toQString();
         int length = qstr.length();
         if (length > 0xFFFFFF) {
             push(data, valueheader(WorkerUndefined));
@@ -177,11 +177,12 @@ void Serialize::serialize(QByteArray &data, const QV4::Value &v, QV8Engine *engi
         char *buffer = data.data() + offset;
 
         memcpy(buffer, qstr.constData(), length*sizeof(QChar));
-    } else if (v.asFunctionObject()) {
+    } else if (v->asFunctionObject()) {
         // XXX TODO: Implement passing function objects between the main and
         // worker scripts
         push(data, valueheader(WorkerUndefined));
-    } else if (QV4::ArrayObject *array = v.asArrayObject()) {
+    } else if (v->asArrayObject()) {
+        QV4::ScopedArrayObject array(scope, v);
         uint32_t length = array->arrayLength();
         if (length > 0xFFFFFF) {
             push(data, valueheader(WorkerUndefined));
@@ -189,25 +190,27 @@ void Serialize::serialize(QByteArray &data, const QV4::Value &v, QV8Engine *engi
         }
         reserve(data, sizeof(quint32) + length * sizeof(quint32));
         push(data, valueheader(WorkerArray, length));
+        ScopedValue val(scope);
         for (uint32_t ii = 0; ii < length; ++ii)
-            serialize(data, QV4::Value::fromReturnedValue(array->getIndexed(ii)), engine);
-    } else if (v.isInteger()) {
+            serialize(data, (val = array->getIndexed(ii)), engine);
+    } else if (v->isInteger()) {
         reserve(data, 2 * sizeof(quint32));
         push(data, valueheader(WorkerInt32));
-        push(data, (quint32)v.integerValue());
+        push(data, (quint32)v->integerValue());
 //    } else if (v->IsUint32()) {
 //        reserve(data, 2 * sizeof(quint32));
 //        push(data, valueheader(WorkerUint32));
 //        push(data, v->Uint32Value());
-    } else if (v.isNumber()) {
+    } else if (v->isNumber()) {
         reserve(data, sizeof(quint32) + sizeof(double));
         push(data, valueheader(WorkerNumber));
-        push(data, v.asDouble());
-    } else if (QV4::DateObject *d = v.asDateObject()) {
+        push(data, v->asDouble());
+    } else if (QV4::DateObject *d = v->asDateObject()) {
         reserve(data, sizeof(quint32) + sizeof(double));
         push(data, valueheader(WorkerDate));
         push(data, d->value.asDouble());
-    } else if (QV4::RegExpObject *re = v.as<RegExpObject>()) {
+    } else if (v->as<RegExpObject>()) {
+        Scoped<RegExpObject> re(scope, v);
         quint32 flags = re->flags();
         QString pattern = re->source();
         int length = pattern.length() + 1;
@@ -226,7 +229,8 @@ void Serialize::serialize(QByteArray &data, const QV4::Value &v, QV8Engine *engi
         char *buffer = data.data() + offset;
 
         memcpy(buffer, pattern.constData(), length*sizeof(QChar));
-    } else if (QV4::QObjectWrapper *qobjectWrapper = v.as<QV4::QObjectWrapper>()) {
+    } else if (v->as<QV4::QObjectWrapper>()) {
+        Scoped<QObjectWrapper> qobjectWrapper(scope, v);
         // XXX TODO: Generalize passing objects between the main thread and worker scripts so
         // that others can trivially plug in their elements.
         QQmlListModel *lm = qobject_cast<QQmlListModel *>(qobjectWrapper->object());
@@ -239,8 +243,8 @@ void Serialize::serialize(QByteArray &data, const QV4::Value &v, QV8Engine *engi
         }
         // No other QObject's are allowed to be sent
         push(data, valueheader(WorkerUndefined));
-    } else if (QV4::Object *o = v.asObject()) {
-
+    } else if (v->asObject()) {
+        ScopedObject o(scope, v);
         if (o->isListType()) {
             // valid sequence.  we generate a length (sequence length + 1 for the sequence type)
             uint32_t seqLength = ScopedValue(scope, o->get(v4->id_length))->toUInt32();
@@ -252,14 +256,15 @@ void Serialize::serialize(QByteArray &data, const QV4::Value &v, QV8Engine *engi
             reserve(data, sizeof(quint32) + length * sizeof(quint32));
             push(data, valueheader(WorkerSequence, length));
             serialize(data, QV4::Primitive::fromInt32(QV4::SequencePrototype::metaTypeForSequence(o)), engine); // sequence type
+            ScopedValue val(scope);
             for (uint32_t ii = 0; ii < seqLength; ++ii)
-                serialize(data, QV4::Value::fromReturnedValue(o->getIndexed(ii)), engine); // sequence elements
+                serialize(data, (val = o->getIndexed(ii)), engine); // sequence elements
 
             return;
         }
 
         // regular object
-        QV4::ScopedValue val(scope, v);
+        QV4::ScopedValue val(scope, *v);
         QV4::ScopedArrayObject properties(scope, QV4::ObjectPrototype::getOwnPropertyNames(v4, val));
         quint32 length = properties->arrayLength();
         if (length > 0xFFFFFF) {
@@ -399,7 +404,7 @@ ReturnedValue Serialize::deserialize(const char *&data, QV8Engine *engine)
     return QV4::Encode::undefined();
 }
 
-QByteArray Serialize::serialize(const QV4::Value &value, QV8Engine *engine)
+QByteArray Serialize::serialize(const QV4::ValueRef value, QV8Engine *engine)
 {
     QByteArray rv;
     serialize(rv, value, engine);
diff --git a/src/qml/jsruntime/qv4serialize_p.h b/src/qml/jsruntime/qv4serialize_p.h
index caedb962b1..a9f40e43cd 100644
--- a/src/qml/jsruntime/qv4serialize_p.h
+++ b/src/qml/jsruntime/qv4serialize_p.h
@@ -65,11 +65,11 @@ namespace QV4 {
 class Serialize {
 public:
 
-    static QByteArray serialize(const Value &, QV8Engine *);
+    static QByteArray serialize(const ValueRef, QV8Engine *);
     static ReturnedValue deserialize(const QByteArray &, QV8Engine *);
 
 private:
-    static void serialize(QByteArray &, const Value &, QV8Engine *);
+    static void serialize(QByteArray &, const ValueRef, QV8Engine *);
     static ReturnedValue deserialize(const char *&, QV8Engine *);
 };
 
diff --git a/src/qml/jsruntime/qv4stringobject.cpp b/src/qml/jsruntime/qv4stringobject.cpp
index 5c36ddd7a2..fd15d7ef73 100644
--- a/src/qml/jsruntime/qv4stringobject.cpp
+++ b/src/qml/jsruntime/qv4stringobject.cpp
@@ -357,7 +357,7 @@ ReturnedValue StringPrototype::method_match(SimpleCallContext *context)
     if (!rx) {
         ScopedCallData callData(scope, 1);
         callData->args[0] = regexp;
-        rx = Value::fromReturnedValue(context->engine->regExpCtor.asFunctionObject()->construct(callData)).as<RegExpObject>();
+        rx = context->engine->regExpCtor.asFunctionObject()->construct(callData);
     }
 
     if (!rx)
diff --git a/src/qml/qml/ftw/qhashedstring_p.h b/src/qml/qml/ftw/qhashedstring_p.h
index e39e695c99..46f0533740 100644
--- a/src/qml/qml/ftw/qhashedstring_p.h
+++ b/src/qml/qml/ftw/qhashedstring_p.h
@@ -56,7 +56,7 @@
 #include <QtCore/qglobal.h>
 #include <QtCore/qstring.h>
 #include <private/qv4string_p.h>
-#include <private/qv4value_p.h>
+#include <private/qv4scopedvalue_p.h>
 
 #include <private/qflagpointer_p.h>
 
@@ -232,8 +232,8 @@ public:
     inline char *cStrData() const { return (char *)ckey; }
     inline quint16 *utf16Data() const { return (quint16 *)strData->data(); }
 
-    inline bool equals(const QV4::Value &string) const {
-        QString s = string.toQStringNoThrow();
+    inline bool equals(const QV4::ValueRef string) const {
+        QString s = string->toQStringNoThrow();
         if (isQString()) {
             QStringDataPtr dd;
             dd.ptr = strData;