Move the writeBinding method into QQmlBinding

It's only called from there; this simplifies the code and will allow
some further optimizations.

Change-Id: I1f0befe620beaa0bbf961fc829881ef7b5c2e435
Reviewed-by: Simon Hausmann <simon.hausmann@theqtcompany.com>

1 files changed, 1 insertions, 160 deletions

diff --git a/src/qml/qml/qqmlproperty.cpp b/src/qml/qml/qqmlproperty.cpp
index 54dfd3aa27..39af82f0eb 100644
--- a/src/qml/qml/qqmlproperty.cpp
+++ b/src/qml/qml/qqmlproperty.cpp
@@ -1072,7 +1072,7 @@ QVariant QQmlPropertyPrivate::readValueProperty()
 }
 
 // helper function to allow assignment / binding to QList<QUrl> properties.
-static QVariant resolvedUrlSequence(const QVariant &value, QQmlContextData *context)
+QVariant QQmlPropertyPrivate::resolvedUrlSequence(const QVariant &value, QQmlContextData *context)
 {
     QList<QUrl> urls;
     if (value.userType() == qMetaTypeId<QUrl>()) {
@@ -1418,165 +1418,6 @@ bool QQmlPropertyPrivate::write(QObject *object,
     return true;
 }
 
-// Returns true if successful, false if an error description was set on expression
-bool QQmlPropertyPrivate::writeBinding(QObject *object,
-                                               const QQmlPropertyData &core,
-                                               QQmlContextData *context,
-                                               QQmlJavaScriptExpression *expression,
-                                               const QV4::Value &result, bool isUndefined,
-                                               WriteFlags flags)
-{
-    Q_ASSERT(object);
-    Q_ASSERT(core.coreIndex != -1);
-
-    QQmlEngine *engine = context->engine;
-    QV8Engine *v8engine = QQmlEnginePrivate::getV8Engine(engine);
-
-#define QUICK_STORE(cpptype, conversion) \
-        { \
-            cpptype o = (conversion); \
-            int status = -1; \
-            void *argv[] = { &o, 0, &status, &flags }; \
-            QMetaObject::metacall(object, QMetaObject::WriteProperty, core.coreIndex, argv); \
-            return true; \
-        } \
-
-
-    if (!isUndefined && !core.isValueTypeVirtual()) {
-        switch (core.propType) {
-        case QMetaType::Int:
-            if (result.isInteger())
-                QUICK_STORE(int, result.integerValue())
-            else if (result.isNumber())
-                QUICK_STORE(int, result.doubleValue())
-            break;
-        case QMetaType::Double:
-            if (result.isNumber())
-                QUICK_STORE(double, result.asDouble())
-            break;
-        case QMetaType::Float:
-            if (result.isNumber())
-                QUICK_STORE(float, result.asDouble())
-            break;
-        case QMetaType::QString:
-            if (result.isString())
-                QUICK_STORE(QString, result.toQStringNoThrow())
-            break;
-        default:
-            if (const QV4::QQmlValueTypeWrapper *vtw = result.as<const QV4::QQmlValueTypeWrapper>()) {
-                if (vtw->d()->valueType->typeId == core.propType) {
-                    return vtw->write(object, core.coreIndex);
-                }
-            }
-            break;
-        }
-    }
-#undef QUICK_STORE
-
-    int type = core.isValueTypeVirtual()?core.valueTypePropType:core.propType;
-
-    QQmlJavaScriptExpression::DeleteWatcher watcher(expression);
-
-    QVariant value;
-    bool isVarProperty = core.isVarProperty();
-
-    if (isUndefined) {
-    } else if (core.isQList()) {
-        value = QV8Engine::getV4(v8engine)->toVariant(result, qMetaTypeId<QList<QObject *> >());
-    } else if (result.isNull() && core.isQObject()) {
-        value = QVariant::fromValue((QObject *)0);
-    } else if (core.propType == qMetaTypeId<QList<QUrl> >()) {
-        value = resolvedUrlSequence(QV8Engine::getV4(v8engine)->toVariant(result, qMetaTypeId<QList<QUrl> >()), context);
-    } else if (!isVarProperty && type != qMetaTypeId<QJSValue>()) {
-        value = QV8Engine::getV4(v8engine)->toVariant(result, type);
-    }
-
-    if (expression->hasError()) {
-        return false;
-    } else if (isVarProperty) {
-        const QV4::FunctionObject *f = result.as<QV4::FunctionObject>();
-        if (f && f->isBinding()) {
-            // we explicitly disallow this case to avoid confusion.  Users can still store one
-            // in an array in a var property if they need to, but the common case is user error.
-            expression->delayedError()->setErrorDescription(QLatin1String("Invalid use of Qt.binding() in a binding declaration."));
-            expression->delayedError()->setErrorObject(object);
-            return false;
-        }
-
-        QQmlVMEMetaObject *vmemo = QQmlVMEMetaObject::get(object);
-        Q_ASSERT(vmemo);
-        vmemo->setVMEProperty(core.coreIndex, result);
-    } else if (isUndefined && core.isResettable()) {
-        void *args[] = { 0 };
-        QMetaObject::metacall(object, QMetaObject::ResetProperty, core.coreIndex, args);
-    } else if (isUndefined && type == qMetaTypeId<QVariant>()) {
-        writeValueProperty(object, core, QVariant(), context, flags);
-    } else if (type == qMetaTypeId<QJSValue>()) {
-        const QV4::FunctionObject *f = result.as<QV4::FunctionObject>();
-        if (f && f->isBinding()) {
-            expression->delayedError()->setErrorDescription(QLatin1String("Invalid use of Qt.binding() in a binding declaration."));
-            expression->delayedError()->setErrorObject(object);
-            return false;
-        }
-        writeValueProperty(object, core, QVariant::fromValue(
-                               QJSValue(QV8Engine::getV4(v8engine), result.asReturnedValue())),
-                           context, flags);
-    } else if (isUndefined) {
-        QString errorStr = QLatin1String("Unable to assign [undefined] to ");
-        if (!QMetaType::typeName(type))
-            errorStr += QLatin1String("[unknown property type]");
-        else
-            errorStr += QLatin1String(QMetaType::typeName(type));
-        expression->delayedError()->setErrorDescription(errorStr);
-        expression->delayedError()->setErrorObject(object);
-        return false;
-    } else if (const QV4::FunctionObject *f = result.as<QV4::FunctionObject>()) {
-        if (f->isBinding())
-            expression->delayedError()->setErrorDescription(QLatin1String("Invalid use of Qt.binding() in a binding declaration."));
-        else
-            expression->delayedError()->setErrorDescription(QLatin1String("Unable to assign a function to a property of any type other than var."));
-        expression->delayedError()->setErrorObject(object);
-        return false;
-    } else if (!writeValueProperty(object, core, value, context, flags)) {
-
-        if (watcher.wasDeleted())
-            return true;
-
-        const char *valueType = 0;
-        const char *propertyType = 0;
-
-        if (value.userType() == QMetaType::QObjectStar) {
-            if (QObject *o = *(QObject **)value.constData()) {
-                valueType = o->metaObject()->className();
-
-                QQmlMetaObject propertyMetaObject = rawMetaObjectForType(QQmlEnginePrivate::get(engine), type);
-                if (!propertyMetaObject.isNull())
-                    propertyType = propertyMetaObject.className();
-            }
-        } else if (value.userType() != QVariant::Invalid) {
-            if (value.userType() == QMetaType::VoidStar)
-                valueType = "null";
-            else
-                valueType = QMetaType::typeName(value.userType());
-        }
-
-        if (!valueType)
-            valueType = "undefined";
-        if (!propertyType)
-            propertyType = QMetaType::typeName(type);
-        if (!propertyType)
-            propertyType = "[unknown property type]";
-
-        expression->delayedError()->setErrorDescription(QLatin1String("Unable to assign ") +
-                                                        QLatin1String(valueType) +
-                                                        QLatin1String(" to ") +
-                                                        QLatin1String(propertyType));
-        expression->delayedError()->setErrorObject(object);
-        return false;
-    }
-
-    return true;
-}
 
 QQmlMetaObject QQmlPropertyPrivate::rawMetaObjectForType(QQmlEnginePrivate *engine, int userType)
 {