src/dbus/qdbusintegrator.cpp
changeset 29 b72c6db6890b
parent 18 2f34d5167611
child 30 5dc02b23752f
equal deleted inserted replaced
25:e24348a560a6 29:b72c6db6890b
   521     QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);
   521     QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);
   522     if (d->mode == QDBusConnectionPrivate::InvalidMode)
   522     if (d->mode == QDBusConnectionPrivate::InvalidMode)
   523         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
   523         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
   524 
   524 
   525     QDBusMessage amsg = QDBusMessagePrivate::fromDBusMessage(message);
   525     QDBusMessage amsg = QDBusMessagePrivate::fromDBusMessage(message);
   526     qDBusDebug() << d << "got message:" << amsg;
   526     qDBusDebug() << d << "got message (signal):" << amsg;
   527 
   527 
   528     return d->handleMessage(amsg) ?
   528     return d->handleMessage(amsg) ?
   529         DBUS_HANDLER_RESULT_HANDLED :
   529         DBUS_HANDLER_RESULT_HANDLED :
   530         DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
   530         DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
   531 }
   531 }
  1685 }
  1685 }
  1686 
  1686 
  1687 void QDBusConnectionPrivate::waitForFinished(QDBusPendingCallPrivate *pcall)
  1687 void QDBusConnectionPrivate::waitForFinished(QDBusPendingCallPrivate *pcall)
  1688 {
  1688 {
  1689     Q_ASSERT(pcall->pending);
  1689     Q_ASSERT(pcall->pending);
  1690     QDBusDispatchLocker locker(PendingCallBlockAction, this);
  1690     Q_ASSERT(!pcall->autoDelete);
  1691     q_dbus_pending_call_block(pcall->pending);
  1691     //Q_ASSERT(pcall->mutex.isLocked()); // there's no such function
  1692     // QDBusConnectionPrivate::processFinishedCall() is called automatically
  1692 
       
  1693     if (pcall->waitingForFinished) {
       
  1694         // another thread is already waiting
       
  1695         pcall->waitForFinishedCondition.wait(&pcall->mutex);
       
  1696     } else {
       
  1697         pcall->waitingForFinished = true;
       
  1698         pcall->mutex.unlock();
       
  1699 
       
  1700         {
       
  1701             QDBusDispatchLocker locker(PendingCallBlockAction, this);
       
  1702             q_dbus_pending_call_block(pcall->pending);
       
  1703             // QDBusConnectionPrivate::processFinishedCall() is called automatically
       
  1704         }
       
  1705         pcall->mutex.lock();
       
  1706     }
  1693 }
  1707 }
  1694 
  1708 
  1695 void QDBusConnectionPrivate::processFinishedCall(QDBusPendingCallPrivate *call)
  1709 void QDBusConnectionPrivate::processFinishedCall(QDBusPendingCallPrivate *call)
  1696 {
  1710 {
  1697     QDBusConnectionPrivate *connection = const_cast<QDBusConnectionPrivate *>(call->connection);
  1711     QDBusConnectionPrivate *connection = const_cast<QDBusConnectionPrivate *>(call->connection);
       
  1712 
       
  1713     QMutexLocker locker(&call->mutex);
  1698 
  1714 
  1699     QDBusMessage &msg = call->replyMessage;
  1715     QDBusMessage &msg = call->replyMessage;
  1700     if (call->pending) {
  1716     if (call->pending) {
  1701         // decode the message
  1717         // decode the message
  1702         DBusMessage *reply = q_dbus_pending_call_steal_reply(call->pending);
  1718         DBusMessage *reply = q_dbus_pending_call_steal_reply(call->pending);
  1723             connection->postEventToThread(MessageResultReceivedAction, call->receiver, e);
  1739             connection->postEventToThread(MessageResultReceivedAction, call->receiver, e);
  1724         else
  1740         else
  1725             qDBusDebug() << "Deliver failed!";
  1741             qDBusDebug() << "Deliver failed!";
  1726     }
  1742     }
  1727 
  1743 
       
  1744     if (call->pending)
       
  1745         q_dbus_pending_call_unref(call->pending);
       
  1746     call->pending = 0;
       
  1747 
       
  1748     locker.unlock();
       
  1749 
  1728     // Are there any watchers?
  1750     // Are there any watchers?
  1729     if (call->watcherHelper)
  1751     if (call->watcherHelper)
  1730         call->watcherHelper->emitSignals(msg, call->sentMessage);
  1752         call->watcherHelper->emitSignals(msg, call->sentMessage);
  1731 
  1753 
  1732     if (msg.type() == QDBusMessage::ErrorMessage)
  1754     if (msg.type() == QDBusMessage::ErrorMessage)
  1733         emit connection->callWithCallbackFailed(QDBusError(msg), call->sentMessage);
  1755         emit connection->callWithCallbackFailed(QDBusError(msg), call->sentMessage);
  1734 
  1756 
  1735     if (call->pending)
  1757     if (call->autoDelete) {
  1736         q_dbus_pending_call_unref(call->pending);
  1758         Q_ASSERT(!call->waitingForFinished); // can't wait on a call with autoDelete!
  1737     call->pending = 0;
       
  1738 
       
  1739     if (call->autoDelete)
       
  1740         delete call;
  1759         delete call;
       
  1760     }
  1741 }
  1761 }
  1742 
  1762 
  1743 int QDBusConnectionPrivate::send(const QDBusMessage& message)
  1763 int QDBusConnectionPrivate::send(const QDBusMessage& message)
  1744 {
  1764 {
  1745     if (QDBusMessagePrivate::isLocal(message))
  1765     if (QDBusMessagePrivate::isLocal(message))
  1877 QDBusPendingCallPrivate *QDBusConnectionPrivate::sendWithReplyAsync(const QDBusMessage &message,
  1897 QDBusPendingCallPrivate *QDBusConnectionPrivate::sendWithReplyAsync(const QDBusMessage &message,
  1878                                                                     int timeout)
  1898                                                                     int timeout)
  1879 {
  1899 {
  1880     if (isServiceRegisteredByThread(message.service())) {
  1900     if (isServiceRegisteredByThread(message.service())) {
  1881         // special case for local calls
  1901         // special case for local calls
  1882         QDBusPendingCallPrivate *pcall = new QDBusPendingCallPrivate;
  1902         QDBusPendingCallPrivate *pcall = new QDBusPendingCallPrivate(message, this);
  1883         pcall->sentMessage = message;
       
  1884         pcall->replyMessage = sendWithReplyLocal(message);
  1903         pcall->replyMessage = sendWithReplyLocal(message);
  1885         pcall->connection = this;
       
  1886 
  1904 
  1887         return pcall;
  1905         return pcall;
  1888     }
  1906     }
  1889 
  1907 
  1890     checkThread();
  1908     checkThread();
  1891     QDBusPendingCallPrivate *pcall = new QDBusPendingCallPrivate;
  1909     QDBusPendingCallPrivate *pcall = new QDBusPendingCallPrivate(message, this);
  1892     pcall->sentMessage = message;
       
  1893     pcall->ref = 0;
  1910     pcall->ref = 0;
  1894 
  1911 
  1895     QDBusError error;
  1912     QDBusError error;
  1896     DBusMessage *msg = QDBusMessagePrivate::toDBusMessage(message, &error);
  1913     DBusMessage *msg = QDBusMessagePrivate::toDBusMessage(message, &error);
  1897     if (!msg) {
  1914     if (!msg) {
  1911     if (q_dbus_connection_send_with_reply(connection, msg, &pending, timeout)) {
  1928     if (q_dbus_connection_send_with_reply(connection, msg, &pending, timeout)) {
  1912         if (pending) {
  1929         if (pending) {
  1913             q_dbus_message_unref(msg);
  1930             q_dbus_message_unref(msg);
  1914 
  1931 
  1915             pcall->pending = pending;
  1932             pcall->pending = pending;
  1916             pcall->connection = this;
       
  1917             q_dbus_pending_call_set_notify(pending, qDBusResultReceived, pcall, 0);
  1933             q_dbus_pending_call_set_notify(pending, qDBusResultReceived, pcall, 0);
  1918 
  1934 
  1919             return pcall;
  1935             return pcall;
  1920         } else {
  1936         } else {
  1921             // we're probably disconnected at this point
  1937             // we're probably disconnected at this point