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>

4 files changed, 160 insertions, 169 deletions

diff --git a/src/qml/qml/qqmlbinding.cpp b/src/qml/qml/qqmlbinding.cpp
index b5a628d7cc..3cd6707cf2 100644
--- a/src/qml/qml/qqmlbinding.cpp
+++ b/src/qml/qml/qqmlbinding.cpp
@@ -190,15 +190,16 @@ void QQmlBinding::update(QQmlPropertyPrivate::WriteFlags flags)
 
         QV4::ScopedValue result(scope, QQmlJavaScriptExpression::evaluate(&isUndefined));
 
-        bool needsErrorLocationData = false;
+        bool error = false;
         if (!watcher.wasDeleted() && !hasError())
-            needsErrorLocationData = !QQmlPropertyPrivate::writeBinding(*m_target, pd, context(),
-                                                                this, result, isUndefined, flags);
+            error = !write(pd, result, isUndefined, flags);
 
         if (!watcher.wasDeleted()) {
 
-            if (needsErrorLocationData)
+            if (error) {
                 delayedError()->setErrorLocation(f->sourceLocation());
+                delayedError()->setErrorObject(m_target.data());
+            }
 
             if (hasError()) {
                 if (!delayedError()->addError(ep)) ep->warning(this->error(context()->engine));
@@ -215,6 +216,153 @@ void QQmlBinding::update(QQmlPropertyPrivate::WriteFlags flags)
         setUpdatingFlag(false);
 }
 
+// Returns true if successful, false if an error description was set on expression
+bool QQmlBinding::write(const QQmlPropertyData &core,
+                       const QV4::Value &result, bool isUndefined,
+                       QQmlPropertyPrivate::WriteFlags flags)
+{
+    Q_ASSERT(m_target.data());
+    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(m_target.data(), 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:
+            break;
+        }
+    }
+#undef QUICK_STORE
+
+    int type = core.isValueTypeVirtual() ? core.valueTypePropType : core.propType;
+
+    QQmlJavaScriptExpression::DeleteWatcher watcher(this);
+
+    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 = QQmlPropertyPrivate::resolvedUrlSequence(QV8Engine::getV4(v8engine)->toVariant(result, qMetaTypeId<QList<QUrl> >()), context());
+    } else if (!isVarProperty && type != qMetaTypeId<QJSValue>()) {
+        value = QV8Engine::getV4(v8engine)->toVariant(result, type);
+    }
+
+    if (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.
+            delayedError()->setErrorDescription(QLatin1String("Invalid use of Qt.binding() in a binding declaration."));
+            return false;
+        }
+
+        QQmlVMEMetaObject *vmemo = QQmlVMEMetaObject::get(m_target.data());
+        Q_ASSERT(vmemo);
+        vmemo->setVMEProperty(core.coreIndex, result);
+    } else if (isUndefined && core.isResettable()) {
+        void *args[] = { 0 };
+        QMetaObject::metacall(m_target.data(), QMetaObject::ResetProperty, core.coreIndex, args);
+    } else if (isUndefined && type == qMetaTypeId<QVariant>()) {
+        QQmlPropertyPrivate::writeValueProperty(m_target.data(), core, QVariant(), context(), flags);
+    } else if (type == qMetaTypeId<QJSValue>()) {
+        const QV4::FunctionObject *f = result.as<QV4::FunctionObject>();
+        if (f && f->isBinding()) {
+            delayedError()->setErrorDescription(QLatin1String("Invalid use of Qt.binding() in a binding declaration."));
+            return false;
+        }
+        QQmlPropertyPrivate::writeValueProperty(m_target.data(), 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));
+        delayedError()->setErrorDescription(errorStr);
+        return false;
+    } else if (const QV4::FunctionObject *f = result.as<QV4::FunctionObject>()) {
+        if (f->isBinding())
+            delayedError()->setErrorDescription(QLatin1String("Invalid use of Qt.binding() in a binding declaration."));
+        else
+            delayedError()->setErrorDescription(QLatin1String("Unable to assign a function to a property of any type other than var."));
+        return false;
+    } else if (!QQmlPropertyPrivate::writeValueProperty(m_target.data(), 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 = QQmlPropertyPrivate::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]";
+
+        delayedError()->setErrorDescription(QLatin1String("Unable to assign ") +
+                                                        QLatin1String(valueType) +
+                                                        QLatin1String(" to ") +
+                                                        QLatin1String(propertyType));
+        return false;
+    }
+
+    return true;
+}
+
 QVariant QQmlBinding::evaluate()
 {
     QQmlEnginePrivate *ep = QQmlEnginePrivate::get(context()->engine);
diff --git a/src/qml/qml/qqmlbinding_p.h b/src/qml/qml/qqmlbinding_p.h
index 18f60a2b39..4d6c67eb47 100644
--- a/src/qml/qml/qqmlbinding_p.h
+++ b/src/qml/qml/qqmlbinding_p.h
@@ -104,6 +104,11 @@ private:
     inline bool enabledFlag() const;
     inline void setEnabledFlag(bool);
     QQmlPropertyData getPropertyData() const;
+
+    bool write(const QQmlPropertyData &core,
+                       const QV4::Value &result, bool isUndefined,
+                       QQmlPropertyPrivate::WriteFlags flags);
+
 };
 
 bool QQmlBinding::updatingFlag() const
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)
 {
diff --git a/src/qml/qml/qqmlproperty_p.h b/src/qml/qml/qqmlproperty_p.h
index 7bbb600ade..d0ffbe80fc 100644
--- a/src/qml/qml/qqmlproperty_p.h
+++ b/src/qml/qml/qqmlproperty_p.h
@@ -140,11 +140,6 @@ public:
     static QQmlBoundSignalExpressionPointer takeSignalExpression(const QQmlProperty &that,
                                                                  QQmlBoundSignalExpression *);
     static bool write(const QQmlProperty &that, const QVariant &, WriteFlags);
-    static bool writeBinding(QObject *, const QQmlPropertyData &,
-                             QQmlContextData *context,
-                             QQmlJavaScriptExpression *expression,
-                             const QV4::Value &result, bool isUndefined,
-                             WriteFlags flags);
     static int valueTypeCoreIndex(const QQmlProperty &that);
     static int bindingIndex(const QQmlProperty &that);
     static int bindingIndex(const QQmlPropertyData &that);
@@ -153,6 +148,8 @@ public:
                         const QObject *receiver, int method_index,
                         int type = 0, int *types = 0);
     static void flushSignal(const QObject *sender, int signal_index);
+
+    static QVariant resolvedUrlSequence(const QVariant &value, QQmlContextData *context);
 };
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(QQmlPropertyPrivate::WriteFlags)