1 files changed, 73 insertions, 50 deletions

diff --git a/src/corelib/kernel/qobject_p.h b/src/corelib/kernel/qobject_p.h
index a762e6f529..823c7a195a 100644
--- a/src/corelib/kernel/qobject_p.h
+++ b/src/corelib/kernel/qobject_p.h
@@ -79,9 +79,9 @@ struct QSignalSpyCallbackSet
     EndCallback signal_end_callback,
                 slot_end_callback;
 };
-void Q_CORE_EXPORT qt_register_signal_spy_callbacks(const QSignalSpyCallbackSet &callback_set);
+void Q_CORE_EXPORT qt_register_signal_spy_callbacks(QSignalSpyCallbackSet *callback_set);
 
-extern QSignalSpyCallbackSet Q_CORE_EXPORT qt_signal_spy_callback_set;
+extern Q_CORE_EXPORT QBasicAtomicPointer<QSignalSpyCallbackSet> qt_signal_spy_callback_set;
 
 enum { QObjectPrivateVersion = QT_VERSION };
 
@@ -167,11 +167,69 @@ public:
 
     struct Sender
     {
+        Sender(QObject *receiver, QObject *sender, int signal)
+            : receiver(receiver), sender(sender), signal(signal)
+        {
+            if (receiver) {
+                ConnectionData *cd = receiver->d_func()->connections.load();
+                previous = cd->currentSender;
+                cd->currentSender = this;
+            }
+        }
+        ~Sender()
+        {
+            if (receiver)
+                receiver->d_func()->connections.load()->currentSender = previous;
+        }
+        void receiverDeleted()
+        {
+            Sender *s = this;
+            while (s) {
+                s->receiver = nullptr;
+                s = s->previous;
+            }
+        }
+        Sender *previous;
+        QObject *receiver;
         QObject *sender;
         int signal;
-        int ref;
     };
 
+    /*
+        This contains the all connections from and to an object.
+
+        The signalVector contains the lists of connections for a given signal. The index in the vector correspond
+        to the signal index. The signal index is the one returned by QObjectPrivate::signalIndex (not
+        QMetaObject::indexOfSignal). allsignals contains a list of special connections that will get invoked on
+        any signal emission. This is done by connecting to signal index -1.
+
+        This vector is protected by the object mutex (signalSlotLock())
+
+        Each Connection is also part of a 'senders' linked list. This one contains all connections connected
+        to a slot in this object. The mutex of the receiver must be locked when touching the pointers of this
+        linked list.
+    */
+    struct ConnectionData {
+        bool objectDeleted = false; //the QObject owner of this vector has been destroyed while the vector was inUse
+        struct Ref {
+            int _ref = 0;
+            void ref() { ++_ref; }
+            int deref() { return --_ref; }
+            operator int() const { return _ref; }
+        };
+
+        Ref ref;
+        bool dirty = false; //some Connection have been disconnected (their receiver is 0) but not removed from the list yet
+        ConnectionList allsignals;
+        QVector<ConnectionList> signalVector;
+        Connection *senders = nullptr;
+        Sender *currentSender = nullptr;   // object currently activating the object
+
+        ConnectionList &connectionsForSignal(int signal)
+        {
+            return signal < 0 ? allsignals : signalVector[signal];
+        }
+    };
 
     QObjectPrivate(int version = QObjectPrivateVersion);
     virtual ~QObjectPrivate();
@@ -189,19 +247,13 @@ public:
     void addConnection(int signal, Connection *c);
     void cleanConnectionLists();
 
-    static inline Sender *setCurrentSender(QObject *receiver,
-                                    Sender *sender);
-    static inline void resetCurrentSender(QObject *receiver,
-                                   Sender *currentSender,
-                                   Sender *previousSender);
-
     static QObjectPrivate *get(QObject *o) {
         return o->d_func();
     }
     static const QObjectPrivate *get(const QObject *o) { return o->d_func(); }
 
     int signalIndex(const char *signalName, const QMetaObject **meta = nullptr) const;
-    inline bool isSignalConnected(uint signalIdx, bool checkDeclarative = true) const;
+    bool isSignalConnected(uint signalIdx, bool checkDeclarative = true) const;
     inline bool isDeclarativeSignalConnected(uint signalIdx) const;
 
     // To allow abitrary objects to call connectNotify()/disconnectNotify() without making
@@ -224,15 +276,21 @@ public:
                                                const int *types, const QMetaObject *senderMetaObject);
     static QMetaObject::Connection connect(const QObject *sender, int signal_index, QtPrivate::QSlotObjectBase *slotObj, Qt::ConnectionType type);
     static bool disconnect(const QObject *sender, int signal_index, void **slot);
+
+    void ensureConnectionData()
+    {
+        if (connections.load())
+            return;
+        ConnectionData *cd = new ConnectionData;
+        cd->ref.ref();
+        connections.store(cd);
+    }
 public:
     ExtraData *extraData;    // extra data set by the user
     QThreadData *threadData; // id of the thread that owns the object
 
-    QObjectConnectionListVector *connectionLists;
-
-    Connection *senders;     // linked list of connections connected to this object
-    Sender *currentSender;   // object currently activating the object
-    mutable quint32 connectedSignals[2];
+    using ConnectionDataPointer = QExplicitlySharedDataPointer<ConnectionData>;
+    QAtomicPointer<ConnectionData> connections;
 
     union {
         QObject *currentChildBeingDeleted; // should only be used when QObjectData::isDeletingChildren is set
@@ -246,47 +304,12 @@ public:
 
 Q_DECLARE_TYPEINFO(QObjectPrivate::ConnectionList, Q_MOVABLE_TYPE);
 
-/*! \internal
-
-  Returns \c true if the signal with index \a signal_index from object \a sender is connected.
-  Signals with indices above a certain range are always considered connected (see connectedSignals
-  in QObjectPrivate).
-
-  \a signal_index must be the index returned by QObjectPrivate::signalIndex;
-*/
-inline bool QObjectPrivate::isSignalConnected(uint signal_index, bool checkDeclarative) const
-{
-    return signal_index >= sizeof(connectedSignals) * 8
-        || (connectedSignals[signal_index >> 5] & (1 << (signal_index & 0x1f))
-        || (checkDeclarative && isDeclarativeSignalConnected(signal_index)));
-}
-
 inline bool QObjectPrivate::isDeclarativeSignalConnected(uint signal_index) const
 {
     return declarativeData && QAbstractDeclarativeData::isSignalConnected
             && QAbstractDeclarativeData::isSignalConnected(declarativeData, q_func(), signal_index);
 }
 
-inline QObjectPrivate::Sender *QObjectPrivate::setCurrentSender(QObject *receiver,
-                                                         Sender *sender)
-{
-    Sender *previousSender = receiver->d_func()->currentSender;
-    receiver->d_func()->currentSender = sender;
-    return previousSender;
-}
-
-inline void QObjectPrivate::resetCurrentSender(QObject *receiver,
-                                        Sender *currentSender,
-                                        Sender *previousSender)
-{
-    // ref is set to zero when this object is deleted during the metacall
-    if (currentSender->ref == 1)
-        receiver->d_func()->currentSender = previousSender;
-    // if we've recursed, we need to tell the caller about the objects deletion
-    if (previousSender)
-        previousSender->ref = currentSender->ref;
-}
-
 inline void QObjectPrivate::connectNotify(const QMetaMethod &signal)
 {
     q_ptr->connectNotify(signal);