QML: Drop the "succeeded" out parameters from SequencePrototype

The success of the operation is visible from the return value in all
cases.

Change-Id: I93177785f76b8078ddd8eeb7d77143993fe80739
Reviewed-by: Semih Yavuz <[email protected]>
Reviewed-by: Fabian Kosmale <[email protected]>

6 files changed, 25 insertions, 41 deletions

diff --git a/src/qml/jsruntime/qv4engine.cpp b/src/qml/jsruntime/qv4engine.cpp
index 91e5c62f8c..7934fe6779 100644
--- a/src/qml/jsruntime/qv4engine.cpp
+++ b/src/qml/jsruntime/qv4engine.cpp
@@ -1565,10 +1565,8 @@ static QVariant toVariant(
             return QVariant::fromValue(QV4::JsonObject::toJsonArray(a));
         }
 
-        QVariant retn;
-        bool succeeded = false;
-        retn = QV4::SequencePrototype::toVariant(value, metaType, &succeeded);
-        if (succeeded)
+        QVariant retn = QV4::SequencePrototype::toVariant(value, metaType);
+        if (retn.isValid())
             return retn;
 
         if (metaType.isValid()) {
@@ -1809,11 +1807,9 @@ QV4::ReturnedValue ExecutionEngine::fromData(QMetaType metaType, const void *ptr
                 return QV4::QObjectWrapper::wrap(this, *reinterpret_cast<QObject* const *>(ptr));
             case QMetaType::QStringList:
                 {
-                bool succeeded = false;
                 QV4::Scope scope(this);
-                QV4::ScopedValue retn(
-                            scope, QV4::SequencePrototype::fromData(this, metaType, ptr, &succeeded));
-                if (succeeded)
+                QV4::ScopedValue retn(scope, QV4::SequencePrototype::fromData(this, metaType, ptr));
+                if (!retn->isUndefined())
                     return retn->asReturnedValue();
                 return QV4::Encode(newArrayObject(*reinterpret_cast<const QStringList *>(ptr)));
                 }
@@ -1879,9 +1875,8 @@ QV4::ReturnedValue ExecutionEngine::fromData(QMetaType metaType, const void *ptr
                 return QV4::QObjectWrapper::wrap(this, *reinterpret_cast<QObject* const *>(ptr));
         }
 
-        bool succeeded = false;
-        QV4::ScopedValue retn(scope, QV4::SequencePrototype::fromData(this, metaType, ptr, &succeeded));
-        if (succeeded)
+        QV4::ScopedValue retn(scope, QV4::SequencePrototype::fromData(this, metaType, ptr));
+        if (!retn->isUndefined())
             return retn->asReturnedValue();
 
         if (QMetaType::canConvert(metaType, QMetaType::fromType<QSequentialIterable>())) {
diff --git a/src/qml/jsruntime/qv4qobjectwrapper.cpp b/src/qml/jsruntime/qv4qobjectwrapper.cpp
index 376332179c..ef8c8c76d6 100644
--- a/src/qml/jsruntime/qv4qobjectwrapper.cpp
+++ b/src/qml/jsruntime/qv4qobjectwrapper.cpp
@@ -168,11 +168,10 @@ static ReturnedValue loadProperty(ExecutionEngine *v4, QObject *object,
     }
 
     // see if it's a sequence type
-    bool succeeded = false;
     QV4::ScopedValue retn(scope, QV4::SequencePrototype::newSequence(
                               v4, propMetaType, object, property.coreIndex(),
-                              !property.isWritable(), &succeeded));
-    if (succeeded)
+                              !property.isWritable()));
+    if (!retn->isUndefined())
         return retn->asReturnedValue();
 
     if (!propMetaType.isValid()) {
diff --git a/src/qml/jsruntime/qv4sequenceobject.cpp b/src/qml/jsruntime/qv4sequenceobject.cpp
index 261c55af30..4415ca4d52 100644
--- a/src/qml/jsruntime/qv4sequenceobject.cpp
+++ b/src/qml/jsruntime/qv4sequenceobject.cpp
@@ -568,7 +568,7 @@ ReturnedValue SequencePrototype::method_sort(const FunctionObject *b, const Valu
 
 ReturnedValue SequencePrototype::newSequence(
         QV4::ExecutionEngine *engine, QMetaType sequenceType, QObject *object,
-        int propertyIndex,  bool readOnly, bool *succeeded)
+        int propertyIndex,  bool readOnly)
 {
     QV4::Scope scope(engine);
     // This function is called when the property is a QObject Q_PROPERTY of
@@ -578,23 +578,20 @@ ReturnedValue SequencePrototype::newSequence(
 
     const QQmlType qmlType = QQmlMetaType::qmlListType(sequenceType);
     if (qmlType.isSequentialContainer()) {
-        *succeeded = true;
         QV4::ScopedObject obj(scope, engine->memoryManager->allocate<Sequence>(
                                   object, propertyIndex, qmlType, readOnly));
         return obj.asReturnedValue();
     }
 
-    *succeeded = false;
     return Encode::undefined();
 }
 
-ReturnedValue SequencePrototype::fromVariant(
-        QV4::ExecutionEngine *engine, const QVariant &v, bool *succeeded)
+ReturnedValue SequencePrototype::fromVariant(QV4::ExecutionEngine *engine, const QVariant &v)
 {
-    return fromData(engine, v.metaType(), v.constData(), succeeded);
+    return fromData(engine, v.metaType(), v.constData());
 }
 
-ReturnedValue SequencePrototype::fromData(ExecutionEngine *engine, QMetaType type, const void *data, bool *succeeded)
+ReturnedValue SequencePrototype::fromData(ExecutionEngine *engine, QMetaType type, const void *data)
 {
     QV4::Scope scope(engine);
     // This function is called when assigning a sequence value to a normal JS var
@@ -604,12 +601,10 @@ ReturnedValue SequencePrototype::fromData(ExecutionEngine *engine, QMetaType typ
 
     const QQmlType qmlType = QQmlMetaType::qmlListType(type);
     if (qmlType.isSequentialContainer()) {
-        *succeeded = true;
         QV4::ScopedObject obj(scope, engine->memoryManager->allocate<Sequence>(qmlType, data));
         return obj.asReturnedValue();
     }
 
-    *succeeded = false;
     return Encode::undefined();
 }
 
@@ -619,14 +614,11 @@ QVariant SequencePrototype::toVariant(const Sequence *object)
     return object->toVariant();
 }
 
-QVariant SequencePrototype::toVariant(const QV4::Value &array, QMetaType typeHint, bool *succeeded)
+QVariant SequencePrototype::toVariant(const QV4::Value &array, QMetaType typeHint)
 {
-    *succeeded = true;
-
-    if (!array.as<ArrayObject>()) {
-        *succeeded = false;
+    if (!array.as<ArrayObject>())
         return QVariant();
-    }
+
     QV4::Scope scope(array.as<Object>()->engine());
     QV4::ScopedArrayObject a(scope, array);
 
@@ -669,7 +661,6 @@ QVariant SequencePrototype::toVariant(const QV4::Value &array, QMetaType typeHin
         return result;
     }
 
-    *succeeded = false;
     return QVariant();
 }
 
diff --git a/src/qml/jsruntime/qv4sequenceobject_p.h b/src/qml/jsruntime/qv4sequenceobject_p.h
index 256d324355..7280d563e3 100644
--- a/src/qml/jsruntime/qv4sequenceobject_p.h
+++ b/src/qml/jsruntime/qv4sequenceobject_p.h
@@ -37,13 +37,13 @@ struct Q_QML_PRIVATE_EXPORT SequencePrototype : public QV4::Object
     static ReturnedValue method_valueOf(const FunctionObject *, const Value *thisObject, const Value *argv, int argc);
     static ReturnedValue method_sort(const FunctionObject *, const Value *thisObject, const Value *argv, int argc);
 
-    static ReturnedValue newSequence(QV4::ExecutionEngine *engine, QMetaType sequenceType, QObject *object, int propertyIndex, bool readOnly, bool *succeeded);
-    static ReturnedValue fromVariant(QV4::ExecutionEngine *engine, const QVariant &v, bool *succeeded);
-    static ReturnedValue fromData(QV4::ExecutionEngine *engine, QMetaType type, const void *data, bool *succeeded);
+    static ReturnedValue newSequence(QV4::ExecutionEngine *engine, QMetaType sequenceType, QObject *object, int propertyIndex, bool readOnly);
+    static ReturnedValue fromVariant(QV4::ExecutionEngine *engine, const QVariant &vd);
+    static ReturnedValue fromData(QV4::ExecutionEngine *engine, QMetaType type, const void *data);
 
     static QMetaType metaTypeForSequence(const Sequence *object);
     static QVariant toVariant(const Sequence *object);
-    static QVariant toVariant(const Value &array, QMetaType typeHint, bool *succeeded);
+    static QVariant toVariant(const Value &array, QMetaType typeHint);
     static void *getRawContainerPtr(const Sequence *object, QMetaType typeHint);
 };
 
diff --git a/src/qml/qml/qqmlvmemetaobject.cpp b/src/qml/qml/qqmlvmemetaobject.cpp
index 20f4021b61..0f4828ac83 100644
--- a/src/qml/qml/qqmlvmemetaobject.cpp
+++ b/src/qml/qml/qqmlvmemetaobject.cpp
@@ -815,10 +815,10 @@ int QQmlVMEMetaObject::metaCall(QObject *o, QMetaObject::Call c, int _id, void *
                                     needActivate = true;
                                 }
                             } else {
-                                bool success = false;
-                                md->set(engine, id, QV4::SequencePrototype::fromData(
-                                            engine, propType, a[0], &success));
-                                if (!success) {
+                                QV4::ScopedValue sequence(scope, QV4::SequencePrototype::fromData(
+                                                              engine, propType, a[0]));
+                                md->set(engine, id, sequence);
+                                if (sequence->isUndefined()) {
                                     qmlWarning(object)
                                             << "Could not create a QML sequence object for "
                                             << propType.name();
diff --git a/src/qmlworkerscript/qv4serialize.cpp b/src/qmlworkerscript/qv4serialize.cpp
index fda96cf763..c0f34ab1fc 100644
--- a/src/qmlworkerscript/qv4serialize.cpp
+++ b/src/qmlworkerscript/qv4serialize.cpp
@@ -384,7 +384,6 @@ ReturnedValue Serialize::deserialize(const char *&data, ExecutionEngine *engine)
     case WorkerSequence:
     {
         ScopedValue value(scope);
-        bool succeeded = false;
         quint32 length = headersize(header);
         quint32 seqLength = length - 1;
         value = deserialize(data, engine);
@@ -396,8 +395,8 @@ ReturnedValue Serialize::deserialize(const char *&data, ExecutionEngine *engine)
             array->arrayPut(ii, value);
         }
         array->setArrayLengthUnchecked(seqLength);
-        QVariant seqVariant = QV4::SequencePrototype::toVariant(array, QMetaType(sequenceType), &succeeded);
-        return QV4::SequencePrototype::fromVariant(engine, seqVariant, &succeeded);
+        QVariant seqVariant = QV4::SequencePrototype::toVariant(array, QMetaType(sequenceType));
+        return QV4::SequencePrototype::fromVariant(engine, seqVariant);
     }
     }
     Q_ASSERT(!"Unreachable");