Implement qScriptConnect(), qScriptDisconnect()

These functions are currently being used by QDeclarative. Needed for
tst_qdeclarativeecmascript.

The semantics are stricter than what the documentation suggests. When
calling qScriptDisconnect(), the connection must have been be made
with qScriptConnect().

Reviewed-by: Olivier

Author: Gabriel de Dietrich

src/script/api/qscriptengine.cpp

@@ -2501,28 +2501,90 @@ QScriptEngineAgent *QScriptEngine::agent() const
     return agent ? QScriptEngineAgentPrivate::get(agent) : 0;
 }
 
+inline v8::Persistent<v8::Object> QScriptEnginePrivate::v8ObjectForConnectedObject(const QObject *o) const
+{
+    return m_connectedObjects.value(o);
+}
+
+inline void QScriptEnginePrivate::addV8ObjectForConnectedObject(const QObject *o, v8::Persistent<v8::Object> v8Object)
+{
+    m_connectedObjects.insert(o, v8Object);
+}
+
+void QScriptEnginePrivate::_q_removeConnectedObject(QObject *o)
+{
+    m_connectedObjects.take(o).Dispose();
+}
+
 bool qScriptConnect(QObject *sender, const char *signal,
                     const QScriptValue &receiver,
                     const QScriptValue &function)
 {
-    Q_UNUSED(sender);
-    Q_UNUSED(signal);
-    Q_UNUSED(receiver);
-    Q_UNUSED(function);
-    Q_UNIMPLEMENTED();
-    return false;
+    if (!sender || !signal)
+        return false;
+    if (!function.isFunction()) {
+        qWarning("qScriptConnect(): 'function' is not a function");
+        return false;
+    }
+    if (receiver.isObject() && (receiver.engine() != function.engine())) {
+        qWarning("qScriptConnect(): 'receiver' and 'function' don't share the same engine");
+        return false;
+    }
+
+    QScriptEnginePrivate *engine = QScriptEnginePrivate::get(function.engine());
+    v8::Handle<v8::Object> v8Sender = engine->v8ObjectForConnectedObject(sender);
+    if (v8Sender.IsEmpty()) {
+        v8Sender = v8::Handle<v8::Object>::Cast(engine->newQObject(sender));
+        engine->addV8ObjectForConnectedObject(sender, v8::Persistent<v8::Object>::New(v8Sender));
+        QObject::connect(sender, SIGNAL(destroyed(QObject*)),
+                         function.engine(), SLOT(_q_removeConnectedObject(QObject*)));
+    }
+
+    QString signalName(signal);
+    signalName.remove(0, 1);
+
+    v8::Handle<v8::Object> signalData =  v8Sender->Get(QScriptConverter::toString(signalName))->ToObject();
+    if (signalData.IsEmpty() || signalData->IsError() || signalData->IsUndefined()) {
+        qWarning("qScriptConnect(): signal '%s' is undefined", qPrintable(signalName));
+        return false;
+    }
+    v8::Handle<v8::Object> v8Receiver;
+    if (receiver.isObject())
+        v8Receiver = v8::Handle<v8::Object>(*QScriptValuePrivate::get(receiver));
+    return !QScriptSignalData::get(signalData)->connect(v8Receiver, v8::Handle<v8::Object>(*QScriptValuePrivate::get(function)))->IsError();
 }
 
 bool qScriptDisconnect(QObject *sender, const char *signal,
                        const QScriptValue &receiver,
                        const QScriptValue &function)
 {
-    Q_UNUSED(sender);
-    Q_UNUSED(signal);
-    Q_UNUSED(receiver);
-    Q_UNUSED(function);
-    Q_UNIMPLEMENTED();
-    return false;
+    if (!sender || !signal)
+        return false;
+    if (!function.isFunction()) {
+        qWarning("qScriptDisconnect(): 'function' is not a function");
+        return false;
+    }
+    if (receiver.isObject() && (receiver.engine() != function.engine())) {
+        qWarning("qScriptDisconnect(): 'receiver' and 'function' don't share the same engine");
+        return false;
+    }
+
+    QScriptEnginePrivate *engine = QScriptEnginePrivate::get(function.engine());
+    v8::Handle<v8::Object> v8Sender = engine->v8ObjectForConnectedObject(sender);
+    if (v8Sender.IsEmpty()) {
+        qWarning("qScriptDisconnect(): 'sender' and ('receiver','function') were not connected with qScriptConnect()");
+        return false;
+    }
+
+    QString signalName(signal);
+    signalName.remove(0, 1);
+
+    v8::Handle<v8::Object> signalData =  v8Sender->Get(QScriptConverter::toString(signalName))->ToObject();
+    if (signalData.IsEmpty() || signalData->IsError() || signalData->IsUndefined()) {
+        qWarning("qScriptDisconnect(): signal '%s' is undefined", qPrintable(signalName));
+        return false;
+    }
+    return !QScriptSignalData::get(signalData)->disconnect(v8::Handle<v8::Function>::Cast(v8::Handle<v8::Value>(*QScriptValuePrivate::get(function))))->IsError();
 }
 
 #ifdef QT_BUILD_INTERNAL
@@ -2576,3 +2638,5 @@ QScriptValue::PropertyFlags QScriptEnginePrivate::getPropertyFlagsFromScriptClas
 }
 
 QT_END_NAMESPACE
+
+#include "moc_qscriptengine.cpp"

src/script/api/qscriptengine.h

@@ -218,6 +218,7 @@ class Q_SCRIPT_EXPORT QScriptEngine
 private:
     Q_DECLARE_PRIVATE(QScriptEngine)
     Q_DISABLE_COPY(QScriptEngine)
+    Q_PRIVATE_SLOT(d_func(), void _q_removeConnectedObject(QObject*))
 };
 
 #define Q_SCRIPT_DECLARE_QMETAOBJECT(T, _Arg1) \

src/script/api/qscriptengine_p.h

@@ -191,6 +191,11 @@ class QScriptEnginePrivate
 
     QScriptValue scriptValueFromInternal(v8::Handle<v8::Value>) const;
 
+    v8::Persistent<v8::Object> v8ObjectForConnectedObject(const QObject *o) const;
+    void addV8ObjectForConnectedObject(const QObject *o, v8::Persistent<v8::Object> v8Object);
+    // private slot
+    void _q_removeConnectedObject(QObject*);
+
     inline operator v8::Handle<v8::Context>();
     inline void clearExceptions();
     inline void setException(v8::Handle<v8::Value> value, v8::Handle<v8::Message> message = v8::Handle<v8::Message>());
@@ -324,6 +329,7 @@ class QScriptEnginePrivate
     QScriptBagContainer<QScriptablePrivate> m_scriptable;
     QScriptBagContainer<QScriptEngineAgentPrivate> m_agents;
     QScriptBagContainer<QScriptEngineAgentPrivate::UnloadData> m_scripts;
+    QHash<const QObject *, v8::Persistent<v8::Object> > m_connectedObjects;
 
     QScriptEngineAgentPrivate *m_currentAgent;
     class ProcessEventTimeoutThread;

src/script/api/qscriptqobject.cpp

@@ -386,13 +386,11 @@ class QtObjectNotifyCaller : public QObject
     }
 };
 
-
 // A C++ signal-to-JS handler connection.
 //
 // Acts as a middle-man; intercepts a C++ signal,
 // and invokes a JS callback function.
 //
-class QScriptSignalData;
 class QScriptConnection : public QObject
 {
 public:
@@ -425,138 +423,12 @@ class QScriptConnection : public QObject
     v8::Persistent<v8::Object> m_receiver;
 };
 
-union QScriptMetaMethodInfo {
-    QScriptMetaMethodInfo(): intData(0)
-    { }
-
-    uint32_t intData;
-    struct {
-        uint index: 28;
-        uint resolveMode: 1;
-        uint overloaded: 1;
-        uint voidvoid: 1;
-        uint padding: 1; // Make sure the struct fits in an SMI
-    };
-};
-
-template <typename T, v8::Persistent<v8::FunctionTemplate> QScriptEnginePrivate::*functionTemplate>
-class QScriptGenericMetaMethodData : public QScriptV8ObjectWrapper<T, functionTemplate> {
-public:
-    enum ResolveMode {
-        ResolvedByName = 0,
-        ResolvedBySignature = 1
-    };
-
-    QScriptGenericMetaMethodData(QScriptEnginePrivate *eng, v8::Handle<v8::Object> object, QScriptMetaMethodInfo info)
-        : m_object(v8::Persistent<v8::Object>::New(object)), m_info(info)
-    {
-        this->engine = eng;
-        // We cannot keep a persistant reference to the object, else it would never be garbage collected.
-        //  (the object also reference us,  and persistent object are automatically marked.
-        //  A reference is kept in the second internal field of the v8 method object.
-        m_object.MakeWeak(this, objectDestroyed);
-    }
-    ~QScriptGenericMetaMethodData()
-    {
-        m_object.Dispose();
-    }
-
-    // The QObject wrapper object that this signal is bound to.
-    v8::Handle<v8::Object> object() const
-    { return m_object; }
-
-    int index() const
-    { return m_info.index; }
-
-    ResolveMode resolveMode() const
-    { return ResolveMode(m_info.resolveMode); }
-
-    v8::Handle<v8::Value> call();
-
-    v8::Persistent<v8::Object> m_object;
-    QScriptMetaMethodInfo m_info;
-private:
-    static void objectDestroyed(v8::Persistent<v8::Value> object, void *data) {
-        QScriptGenericMetaMethodData *that = static_cast<QScriptGenericMetaMethodData *>(data);
-        Q_ASSERT(that->m_object == object);
-        that->m_object.Clear();
-        object.Dispose();
-        // Note that since the method keep a reference to the object in its internal field,
-        // this is only called when the QScriptGenericMetaMethodData is about to be garbage collected as well.
-    }
-};
-
-class QScriptMetaMethodData : public QScriptGenericMetaMethodData<QScriptMetaMethodData, &QScriptEnginePrivate::metaMethodTemplate>
+QScriptSignalData::~QScriptSignalData()
 {
-    typedef QScriptGenericMetaMethodData<QScriptMetaMethodData, &QScriptEnginePrivate::metaMethodTemplate> Base;
-public:
-    QScriptMetaMethodData(QScriptEnginePrivate *engine, v8::Handle<v8::Object> object, QScriptMetaMethodInfo info)
-    : Base(engine, object, info)
-    { }
-
-    static v8::Handle<v8::FunctionTemplate> createFunctionTemplate(QScriptEnginePrivate *engine);
-};
-
-// Data associated with a signal JS wrapper object.
-//
-// A signal wrapper is bound to the particular Qt wrapper object
-// where it was looked up as a member, i.e. signal wrappers are
-// _per instance_, not per class (prototype). This is in order
-// to support the connect() and disconnect() syntax:
-//
-// button1.clicked.connect(...);
-// button2.clicked.connect(...);
-//
-// When connect() is called, the this-object will be the signal
-// wrapper, not the QObject. Hence, in order to know which object's
-// clicked() signal to connect to, the signal must be bound to
-// that object.
-//
-// - object: The Qt wrapper object that this signal is bound to.
-//
-// - index: The index of the C++ signal.
-//
-// - resolve mode: How the signal was resolved; by name or signature.
-//   If it was resolved by name, there's a chance the signal might have overloads.
-//
-class QScriptSignalData : public QScriptGenericMetaMethodData<QScriptSignalData, &QScriptEnginePrivate::signalTemplate>
-{
-    typedef QScriptGenericMetaMethodData<QScriptSignalData, &QScriptEnginePrivate::signalTemplate> Base;
-public:
-
-    QScriptSignalData(QScriptEnginePrivate *engine, v8::Handle<v8::Object> object, QScriptMetaMethodInfo info)
-        : Base(engine, object, info)
-    { }
-
-    ~QScriptSignalData()
-    {
-        foreach (QScriptConnection *connection, m_connections) {
-            delete connection;
-        }
+    foreach (QScriptConnection *connection, m_connections) {
+        delete connection;
     }
-
-    static v8::Handle<v8::FunctionTemplate> createFunctionTemplate(QScriptEnginePrivate *engine);
-
-    v8::Handle<v8::Value> connect(v8::Handle<v8::Object> receiver,
-                                  v8::Handle<v8::Object> slot,
-                                  Qt::ConnectionType type = Qt::AutoConnection);
-    v8::Handle<v8::Value> disconnect(v8::Handle<v8::Function> callback);
-
-    static QScriptSignalData *get(v8::Handle<v8::Object> object)
-    {
-        void *ptr = object->GetPointerFromInternalField(0);
-        Q_ASSERT(ptr != 0);
-        return static_cast<QScriptSignalData*>(ptr);
-    }
-
-    void unregisterQScriptConnection(QScriptConnection *connection) { m_connections.removeAll(connection); }
-private:
-    static v8::Handle<v8::Value> QtConnectCallback(const v8::Arguments& args);
-    static v8::Handle<v8::Value> QtDisconnectCallback(const v8::Arguments& args);
-    QList<QScriptConnection*> m_connections;
-};
-
-
+}
 
 v8::Handle<v8::FunctionTemplate> QScriptSignalData::createFunctionTemplate(QScriptEnginePrivate* engine)
 {