Changeset 769 for trunk/src/dbus

Timestamp:

Aug 2, 2010, 9:27:30 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.3 sources from branches/vendor/nokia/qt.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/dbus/qdbusargument.cpp (modified) (1 diff)
• src/dbus/qdbusconnection.cpp (modified) (2 diffs)
• src/dbus/qdbusintegrator.cpp (modified) (17 diffs)
• src/dbus/qdbusinterface.cpp (modified) (1 diff)
• src/dbus/qdbusmacros.h (modified) (1 diff)
• src/dbus/qdbusmarshaller.cpp (modified) (3 diffs)
• src/dbus/qdbuspendingcall.cpp (modified) (9 diffs)
• src/dbus/qdbuspendingcall_p.h (modified) (3 diffs)
• src/dbus/qdbuspendingreply.cpp (modified) (2 diffs)

trunk/src/dbus/qdbusargument.cpp

@@ -536 +536 @@
 /*!
     \internal
-    Returns the type signature of the D-Bus type this QDBusArgument
     \since 4.5
 

trunk/src/dbus/qdbusconnection.cpp

@@ -492 +492 @@
     QDBusMessage::ReplyMessage or QDBusMessage::ErrorMessage.
 
+
+
+
+
+
+
     See the QDBusInterface::call() function for a more friendly way
     of placing calls.
@@ -527 +533 @@
     immediately. This function is suitable for method calls only. It
     returns an object of type QDBusPendingCall which can be used to
-    track the status of the reply. The \a timeout parameter is used to
-    determine when an auto-generated error reply may be emitted and is
-    also the upper limit for waiting in QDBusPendingCall::waitForFinished().
+    track the status of the reply.
+
+    If no reply is received within \a timeout milliseconds, an automatic
+    error will be delivered indicating the expiration of the call. The
+    default \a timeout is -1, which will be replaced with an
+    implementation-defined value that is suitable for inter-process
+    communications (generally, 25 seconds). This timeout is also the
+    upper limit for waiting in QDBusPendingCall::waitForFinished().
 
     See the QDBusInterface::asyncCall() function for a more friendly way

trunk/src/dbus/qdbusintegrator.cpp

@@ -524 +524 @@
 
     QDBusMessage amsg = QDBusMessagePrivate::fromDBusMessage(message);
-    qDBusDebug() << d << "got message:" << amsg;
+    qDBusDebug() << d << "got message:" << amsg;
 
     return d->handleMessage(amsg) ?
@@ -1661 +1661 @@
 
     QString busService = QLatin1String(DBUS_SERVICE_DBUS);
-    WatchedServicesHash::mapped_type &bus = watchedServices[busService];
-    bus.refcount = 1;
-    bus.owner = getNameOwnerNoCache(busService);
     connectSignal(busService, QString(), QString(), QLatin1String("NameAcquired"), QStringList(), QString(),
                   this, SLOT(registerService(QString)));
@@ -1691 +1688 @@
 {
     Q_ASSERT(pcall->pending);
-    QDBusDispatchLocker locker(PendingCallBlockAction, this);
-    q_dbus_pending_call_block(pcall->pending);
-    // QDBusConnectionPrivate::processFinishedCall() is called automatically
+    Q_ASSERT(!pcall->autoDelete);
+    //Q_ASSERT(pcall->mutex.isLocked()); // there's no such function
+
+    if (pcall->waitingForFinished) {
+        // another thread is already waiting
+        pcall->waitForFinishedCondition.wait(&pcall->mutex);
+    } else {
+        pcall->waitingForFinished = true;
+        pcall->mutex.unlock();
+
+        {
+            QDBusDispatchLocker locker(PendingCallBlockAction, this);
+            q_dbus_pending_call_block(pcall->pending);
+            // QDBusConnectionPrivate::processFinishedCall() is called automatically
+        }
+        pcall->mutex.lock();
+    }
 }
 
@@ -1699 +1710 @@
 {
     QDBusConnectionPrivate *connection = const_cast<QDBusConnectionPrivate *>(call->connection);
+
+
 
     QDBusMessage &msg = call->replyMessage;
@@ -1729 +1742 @@
     }
 
+
+
+
+
+
+
     // Are there any watchers?
     if (call->watcherHelper)
@@ -1736 +1755 @@
         emit connection->callWithCallbackFailed(QDBusError(msg), call->sentMessage);
 
-    if (call->pending)
-        q_dbus_pending_call_unref(call->pending);
-    call->pending = 0;
-
-    if (call->autoDelete)
+    if (call->autoDelete) {
+        Q_ASSERT(!call->waitingForFinished); // can't wait on a call with autoDelete!
         delete call;
+
 }
 
@@ -1883 +1900 @@
     if (isServiceRegisteredByThread(message.service())) {
         // special case for local calls
-        QDBusPendingCallPrivate *pcall = new QDBusPendingCallPrivate;
-        pcall->sentMessage = message;
+        QDBusPendingCallPrivate *pcall = new QDBusPendingCallPrivate(message, this);
         pcall->replyMessage = sendWithReplyLocal(message);
-        pcall->connection = this;
 
         return pcall;
@@ -1892 +1907 @@
 
     checkThread();
-    QDBusPendingCallPrivate *pcall = new QDBusPendingCallPrivate;
-    pcall->sentMessage = message;
+    QDBusPendingCallPrivate *pcall = new QDBusPendingCallPrivate(message, this);
     pcall->ref = 0;
 
@@ -1917 +1931 @@
 
             pcall->pending = pending;
-            pcall->connection = this;
             q_dbus_pending_call_set_notify(pending, qDBusResultReceived, pcall, 0);
 
@@ -1941 +1954 @@
     Q_ASSERT(pcall);
 
-    // has it already finished (dispatched locally)?
+    // has it already finished (dispatched locally)?
     if (pcall->replyMessage.type() == QDBusMessage::ReplyMessage) {
         pcall->setReplyCallback(receiver, returnMethod);
@@ -1949 +1962 @@
     }
 
+
+
+
+
+
+
+
+
     // has it already finished and is an error reply message?
     if (pcall->replyMessage.type() == QDBusMessage::ErrorMessage) {
-        if (errorMethod) {
-            pcall->watcherHelper = new QDBusPendingCallWatcherHelper;
-            connect(pcall->watcherHelper, SIGNAL(error(QDBusError,QDBusMessage)), receiver, errorMethod);
-            pcall->watcherHelper->moveToThread(thread());
-        }
         processFinishedCall(pcall);
         delete pcall;
@@ -1961 +1977 @@
     }
 
-    // has it already finished with error?
-    if (pcall->replyMessage.type() != QDBusMessage::InvalidMessage) {
-        delete pcall;
-        return 0;
-    }
-
     pcall->autoDelete = true;
     pcall->ref.ref();
-
     pcall->setReplyCallback(receiver, returnMethod);
-    if (errorMethod) {
-        pcall->watcherHelper = new QDBusPendingCallWatcherHelper;
-        connect(pcall->watcherHelper, SIGNAL(error(QDBusError,QDBusMessage)), receiver, errorMethod);
-        pcall->watcherHelper->moveToThread(thread());
-    }
 
     return 1;
@@ -2005 +2009 @@
             entry.signature == hook.signature &&
             entry.obj == hook.obj &&
-            entry.midx == hook.midx) {
+            entry.midx == hook.midx &&
+            entry.argumentMatch == hook.argumentMatch) {
             // no need to compare the parameters if it's the same slot
             return true;        // already there
@@ -2047 +2052 @@
             if (shouldWatchService(hook.service)) {
                 WatchedServicesHash::mapped_type &data = watchedServices[hook.service];
-                if (data.refcount) {
-                    // already watching
-                    ++data.refcount;
-                } else {
+                if (++data.refcount == 1) {
                     // we need to watch for this service changing
                     QString dbusServerService = QLatin1String(DBUS_SERVICE_DBUS);
@@ -2090 +2092 @@
             entry.signature == hook.signature &&
             entry.obj == hook.obj &&
-            entry.midx == hook.midx) {
+            entry.midx == hook.midx &&
+            entry.argumentMatch == hook.argumentMatch) {
             // no need to compare the parameters if it's the same slot
             disconnectSignal(it);
@@ -2105 +2108 @@
 {
     const SignalHook &hook = it.value();
-
-    WatchedServicesHash::Iterator sit = watchedServices.find(hook.service);
-    if (sit != watchedServices.end()) {
-        if (sit.value().refcount == 1) {
-            watchedServices.erase(sit);
-            QString dbusServerService = QLatin1String(DBUS_SERVICE_DBUS);
-            disconnectSignal(dbusServerService, QString(), QLatin1String(DBUS_INTERFACE_DBUS),
-                          QLatin1String("NameOwnerChanged"), QStringList() << hook.service, QString(),
-                          this, SLOT(_q_serviceOwnerChanged(QString,QString,QString)));
-        } else {
-            --sit.value().refcount;
-        }
-    }
 
     bool erase = false;
@@ -2137 +2127 @@
         qDBusDebug("Removing rule: %s", hook.matchRule.constData());
         q_dbus_bus_remove_match(connection, hook.matchRule, NULL);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     }
 

trunk/src/dbus/qdbusinterface.cpp

@@ -259 +259 @@
 {
     _id = QDBusAbstractInterface::qt_metacall(_c, _id, _a);
-    if (_id < 0 || !d_func()->isValid)
+    if (_id < 0 || !d_func()->isValid)
         return _id;
     return d_func()->metacall(_c, _id, _a);

trunk/src/dbus/qdbusmacros.h

@@ -49 +49 @@
 #if defined(QDBUS_MAKEDLL)
 # define QDBUS_EXPORT Q_DECL_EXPORT
+
+
 #else
-# define QDBUS_EXPORT Q_DECL_IMPORT
+# define QDBUS_EXPORT
 #endif
 

trunk/src/dbus/qdbusmarshaller.cpp

@@ -41 +41 @@
 
 #include "qdbusargument_p.h"
+
 #include "qdbusutil_p.h"
 
@@ -168 +169 @@
     QByteArray tmpSignature;
     const char *signature = 0;
-    if (int(id) == qMetaTypeId<QDBusArgument>()) {
+    if (int(id) == ) {
         // take the signature from the QDBusArgument object we're marshalling
         tmpSignature =
@@ -354 +355 @@
 
     // intercept QDBusArgument parameters here
-    if (id == qMetaTypeId<QDBusArgument>()) {
+    if (id == ) {
         QDBusArgument dbusargument = qvariant_cast<QDBusArgument>(arg);
         QDBusArgumentPrivate *d = QDBusArgumentPrivate::d(dbusargument);

trunk/src/dbus/qdbuspendingcall.cpp

@@ -209 +209 @@
 void QDBusPendingCallPrivate::checkReceivedSignature()
 {
+
+
     if (replyMessage.type() == QDBusMessage::InvalidMessage)
         return;                 // not yet finished - no message to
@@ -231 +233 @@
 void QDBusPendingCallPrivate::waitForFinished()
 {
+
+
     if (replyMessage.type() != QDBusMessage::InvalidMessage)
         return;                 // already finished
@@ -311 +315 @@
 bool QDBusPendingCall::isFinished() const
 {
-    return !d || (d->replyMessage.type() != QDBusMessage::InvalidMessage);
+    if (!d)
+        return true; // considered finished
+
+    QMutexLocker locker(&d->mutex);
+    return d->replyMessage.type() != QDBusMessage::InvalidMessage;
 }
 
@@ -330 +338 @@
 bool QDBusPendingCall::isValid() const
 {
-    return d ? d->replyMessage.type() == QDBusMessage::ReplyMessage : false;
+    if (!d)
+        return false;
+    QMutexLocker locker(&d->mutex);
+    return d->replyMessage.type() == QDBusMessage::ReplyMessage;
 }
 
@@ -344 +355 @@
 bool QDBusPendingCall::isError() const
 {
-    return d ? d->replyMessage.type() == QDBusMessage::ErrorMessage : true;
+    if (!d)
+        return true; // considered finished and an error
+    QMutexLocker locker(&d->mutex);
+    return d->replyMessage.type() == QDBusMessage::ErrorMessage;
 }
 
@@ -357 +371 @@
 QDBusError QDBusPendingCall::error() const
 {
-    if (d)
+    if (d) {
+        QMutexLocker locker(&d->mutex);
         return d->replyMessage;
+
 
     // not connected, return an error
@@ -379 +395 @@
 QDBusMessage QDBusPendingCall::reply() const
 {
-    return d ? d->replyMessage : QDBusMessage::createError(error());
+    if (!d)
+        return QDBusMessage::createError(error());
+    QMutexLocker locker(&d->mutex);
+    return d->replyMessage;
 }
 
@@ -440 +459 @@
     if (msg.type() == QDBusMessage::ErrorMessage ||
         msg.type() == QDBusMessage::ReplyMessage) {
-        d = new QDBusPendingCallPrivate;
+        d = new QDBusPendingCallPrivate;
         d->replyMessage = msg;
-        d->connection = 0;
     }
 
@@ -472 +490 @@
 {
     if (d) {                    // QDBusPendingCall::d
+
         if (!d->watcherHelper) {
             d->watcherHelper = new QDBusPendingCallWatcherHelper;
-            if (isFinished()) {
+            if () {
                 // cause a signal emission anyways
                 QMetaObject::invokeMethod(d->watcherHelper, "finished", Qt::QueuedConnection);

trunk/src/dbus/qdbuspendingcall_p.h

@@ -58 +58 @@
 #include <qpointer.h>
 #include <qlist.h>
+
+
 
 #include "qdbusmessage.h"
@@ -72 +74 @@
 {
 public:
-    QDBusMessage sentMessage;
-    QDBusMessage replyMessage;
-//    QDBusMessage pendingReplyMessage; // used in the local loop
-    QDBusPendingCallWatcherHelper *watcherHelper;
-    DBusPendingCall *pending;
-    QDBusConnectionPrivate *connection;
+    // {
+    //     set only during construction:
+    const QDBusMessage sentMessage;
+    QDBusConnectionPrivate * const connection;
 
-    QString expectedReplySignature;
-    int expectedReplyCount;
-
-    // for the callback
+    // for the callback mechanism (see setReplyCallback and QDBusConnectionPrivate::sendWithReplyAsync)
     QPointer<QObject> receiver;
     QList<int> metaTypes;
@@ -88 +85 @@
 
     bool autoDelete;
+
 
-    QDBusPendingCallPrivate() : watcherHelper(0), pending(0), autoDelete(false)
+    mutable QMutex mutex;
+    QWaitCondition waitForFinishedCondition;
+
+    // {
+    //    protected by the mutex above:
+    QDBusPendingCallWatcherHelper *watcherHelper;
+    QDBusMessage replyMessage;
+    DBusPendingCall *pending;
+    volatile bool waitingForFinished;
+
+    QString expectedReplySignature;
+    int expectedReplyCount;
+    // }
+
+    QDBusPendingCallPrivate(const QDBusMessage &sent, QDBusConnectionPrivate *connection)
+        : sentMessage(sent), connection(connection), autoDelete(false), watcherHelper(0), pending(0), waitingForFinished(false)
     { }
     ~QDBusPendingCallPrivate();

trunk/src/dbus/qdbuspendingreply.cpp

@@ -253 +253 @@
 void QDBusPendingReplyData::assign(const QDBusMessage &message)
 {
-    d = new QDBusPendingCallPrivate; // drops the reference to the old one
+    d = new QDBusPendingCallPrivate; // drops the reference to the old one
     d->replyMessage = message;
 }
@@ -272 +272 @@
 {
     Q_ASSERT(d);
+
     d->setMetaTypes(count, types);
     d->checkReceivedSignature();