Changeset 561 for trunk/src/dbus/qdbusintegrator.cpp

Timestamp:

Feb 11, 2010, 11:19:06 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.1 sources.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/dbus/qdbusintegrator.cpp (modified) (40 diffs)

trunk/src/dbus/qdbusintegrator.cpp

@@ -2 +2 @@
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtDBus module of the Qt Toolkit.
@@ -21 +22 @@
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
@@ -34 +34 @@
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
@@ -75 +75 @@
     if (th && !th->objectName().isEmpty())
         dbg.nospace() << ", name=" << th->objectName();
-    dbg.nospace() << ")";
+    dbg.nospace() << ')';
     return dbg.space();
 }
@@ -91 +91 @@
     else
         dbg.nospace() << conn->thread();
-    dbg.nospace() << ")";
+    dbg.nospace() << ')';
     return dbg.space();
 }
@@ -391 +391 @@
 } // extern "C"
 
-static QByteArray buildMatchRule(const QString &service, const QString & /*owner*/,
+static QByteArray buildMatchRule(const QString &service,
                                  const QString &objectPath, const QString &interface,
-                                 const QString &member, const QString & /*signature*/)
+                                 const QString &member, const QStringList &argMatch, const QString & /*signature*/)
 {
     QString result = QLatin1String("type='signal',");
@@ -406 +406 @@
     if (!member.isEmpty())
         result += keyValue.arg(QLatin1String("member"), member);
+
+    // add the argument string-matching now
+    if (!argMatch.isEmpty()) {
+        keyValue = QLatin1String("arg%1='%2',");
+        for (int i = 0; i < argMatch.count(); ++i)
+            if (!argMatch.at(i).isNull())
+                result += keyValue.arg(i).arg(argMatch.at(i));
+    }
 
     result.chop(1);             // remove ending comma
@@ -492 +500 @@
     // object not found
     return 0;
+}
+
+static bool shouldWatchService(const QString &service)
+{
+    return !service.isEmpty() && !service.startsWith(QLatin1Char(':'));
 }
 
@@ -566 +579 @@
     QDBusConnectionPrivate::ObjectTreeNode::DataList::ConstIterator end = haystack.children.constEnd();
     for ( ; it != end; ++it)
-        huntAndEmit(connection, msg, needle, *it, isScriptable, isAdaptor, path + QLatin1String("/") + it->name);
+        huntAndEmit(connection, msg, needle, *it, isScriptable, isAdaptor, path + QLatin1Char('/') + it->name);
 
     if (needle == haystack.obj) {
@@ -921 +934 @@
       rootNode(QString(QLatin1Char('/')))
 {
-    static const bool threads = qDBusInitThreads();
-    static const int debugging = ::isDebugging = qgetenv("QDBUS_DEBUG").toInt();
+    static const bool threads = q_dbus_threads_init_default();
+    static const int debugging = qgetenv("QDBUS_DEBUG").toInt();
+    ::isDebugging = debugging;
     Q_UNUSED(threads)
+    Q_UNUSED(debugging)
 
 #ifdef QDBUS_THREAD_DEBUG
@@ -933 +948 @@
 
     rootNode.flags = 0;
-
-    connect(this, SIGNAL(serviceOwnerChanged(QString,QString,QString)),
-            this, SLOT(_q_serviceOwnerChanged(QString,QString,QString)));
 }
 
@@ -1103 +1115 @@
 
     for (int i = 0; i < pendingWatches.size(); ++i)
-        if (!q_dbus_watch_handle(pendingWatches[i], DBUS_WATCH_READABLE))
+        if (!q_dbus_watch_handle(pendingWatches[i], DBUS_WATCH_WRITABLE))
             qDebug("OUT OF MEM");
 }
@@ -1126 +1138 @@
                                          const QVariantList &args)
 {
-    int mciid = mo->indexOfClassInfo(QCLASSINFO_DBUS_INTERFACE);
-    Q_ASSERT(mciid != -1);
-
-    QMetaClassInfo mci = mo->classInfo(mciid);
-    Q_ASSERT(mci.value());
-    const char *interface = mci.value();
+    QString interface = qDBusInterfaceFromMetaObject(mo);
 
     QMetaMethod mm = mo->method(signalId);
@@ -1147 +1154 @@
 
     QDBusReadLocker locker(RelaySignalAction, this);
-    QDBusMessage message = QDBusMessage::createSignal(QLatin1String("/"), QLatin1String(interface),
+    QDBusMessage message = QDBusMessage::createSignal(QLatin1String("/"), interface,
                                                       QLatin1String(memberName));
+    QDBusMessagePrivate::setParametersValidated(message, true);
     message.setArguments(args);
-    DBusMessage *msg = QDBusMessagePrivate::toDBusMessage(message);
+    QDBusError error;
+    DBusMessage *msg = QDBusMessagePrivate::toDBusMessage(message, &error);
     if (!msg) {
-        qWarning("QDBusConnection: Could not emit signal %s.%s", interface, memberName.constData());
+        qWarning("QDBusConnection: Could not emit signal %s.%s: %s", qPrintable(interface), memberName.constData(),
+                 qPrintable(error.message()));
+        lastError = error;
         return;
     }
@@ -1166 +1177 @@
                                                     const QString &oldOwner, const QString &newOwner)
 {
-    if (oldOwner == baseService)
-        unregisterService(name);
-    if (newOwner == baseService)
-        registerService(name);
-
+    Q_UNUSED(oldOwner);
     QDBusWriteLocker locker(UpdateSignalHookOwnerAction, this);
-    QMutableHashIterator<QString, SignalHook> it(signalHooks);
-    it.toFront();
-    while (it.hasNext())
-        if (it.next().value().service == name)
-            it.value().owner = newOwner;
+    WatchedServicesHash::Iterator it = watchedServices.find(name);
+    if (it == watchedServices.end())
+        return;
+    if (oldOwner != it->owner)
+        qWarning("QDBusConnection: name '%s' had owner '%s' but we thought it was '%s'",
+                 qPrintable(name), qPrintable(oldOwner), qPrintable(it->owner));
+
+    qDBusDebug() << this << "Updating name" << name << "from" << oldOwner << "to" << newOwner;
+    it->owner = newOwner;
 }
 
@@ -1194 +1205 @@
 
 bool QDBusConnectionPrivate::prepareHook(QDBusConnectionPrivate::SignalHook &hook, QString &key,
-                                         const QString &service, const QString &owner,
+                                         const QString &service,
                                          const QString &path, const QString &interface, const QString &name,
+                                         const QStringList &argMatch,
                                          QObject *receiver, const char *signal, int minMIdx,
                                          bool buildSignature)
@@ -1212 +1224 @@
 
     hook.service = service;
-    hook.owner = owner; // we don't care if the service has an owner yet
     hook.path = path;
     hook.obj = receiver;
+    hook.argumentMatch = argMatch;
 
     // build the D-Bus signal name and signature
@@ -1236 +1248 @@
     }
 
-    hook.matchRule = buildMatchRule(service, owner, path, interface, mname, hook.signature);
+    hook.matchRule = buildMatchRule(service, path, interface, mname, argMatch, hook.signature);
     return true;                // connect to this signal
 }
@@ -1365 +1377 @@
     if (node.flags & (QDBusConnection::ExportScriptableSlots|QDBusConnection::ExportNonScriptableSlots)) {
         bool interfaceFound = true;
-        if (!msg.interface().isEmpty()) {
-            // check if the interface name matches anything in the class hierarchy
-            const QMetaObject *mo = node.obj->metaObject();
-            for ( ; !interfaceFound && mo != &QObject::staticMetaObject; mo = mo->superClass())
-                interfaceFound = msg.interface() == qDBusInterfaceFromMetaObject(mo);
-        }
+        if (!msg.interface().isEmpty())
+            interfaceFound = qDBusInterfaceInObject(node.obj, msg.interface());
 
         if (interfaceFound) {
@@ -1483 +1491 @@
     for ( ; it != end && it.key() == key; ++it) {
         const SignalHook &hook = it.value();
-        if (!hook.owner.isEmpty() && hook.owner != msg.service())
-            continue;
+        if (!hook.service.isEmpty()) {
+            const QString owner =
+                    shouldWatchService(hook.service) ?
+                    watchedServices.value(hook.service).owner :
+                    hook.service;
+            if (owner != msg.service())
+                continue;
+        }
         if (!hook.path.isEmpty() && hook.path != msg.path())
             continue;
@@ -1491 +1505 @@
         if (hook.signature.isEmpty() && !hook.signature.isNull() && !msg.signature().isEmpty())
             continue;
+        if (!hook.argumentMatch.isEmpty()) {
+            const QVariantList arguments = msg.arguments();
+            if (hook.argumentMatch.size() > arguments.size())
+                continue;
+
+            bool matched = true;
+            for (int i = 0; i < hook.argumentMatch.size(); ++i) {
+                const QString &param = hook.argumentMatch.at(i);
+                if (param.isNull())
+                    continue;   // don't try to match against this
+                if (param == arguments.at(i).toString())
+                    continue;   // matched
+                matched = false;
+                break;
+            }
+            if (!matched)
+                continue;
+        }
 
         activateSignal(hook, msg);
@@ -1625 +1657 @@
         baseService = QString::fromUtf8(service);
     } else {
-        qWarning("QDBusConnectionPrivate::SetConnection: Unable to get base service");
-    }
+        qWarning("QDBusConnectionPrivate::setConnection: Unable to get base service");
+    }
+
+    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)));
+    connectSignal(busService, QString(), QString(), QLatin1String("NameLost"), QStringList(), QString(),
+                  this, SLOT(unregisterService(QString)));
+
 
     q_dbus_connection_add_filter(connection, qDBusSignalFilter, this, 0);
@@ -1708 +1750 @@
                                 // through the d_ptr->localReply link
 
-    DBusMessage *msg = QDBusMessagePrivate::toDBusMessage(message);
+    QDBusError error;
+    DBusMessage *msg = QDBusMessagePrivate::toDBusMessage(message, &error);
     if (!msg) {
         if (message.type() == QDBusMessage::MethodCallMessage)
-            qWarning("QDBusConnection: error: could not send message to service \"%s\" path \"%s\" interface \"%s\" member \"%s\"",
+            qWarning("QDBusConnection: error: could not send message to service \"%s\" path \"%s\" interface \"%s\" member \"%s\": %s",
                      qPrintable(message.service()), qPrintable(message.path()),
-                     qPrintable(message.interface()), qPrintable(message.member()));
+                     qPrintable(message.interface()), qPrintable(message.member()),
+                     qPrintable(error.message()));
         else if (message.type() == QDBusMessage::SignalMessage)
-            qWarning("QDBusConnection: error: could not send signal path \"%s\" interface \"%s\" member \"%s\"",
+            qWarning("QDBusConnection: error: could not send signal path \"%s\" interface \"%s\" member \"%s\": %s",
                      qPrintable(message.path()), qPrintable(message.interface()),
-                     qPrintable(message.member()));
+                     qPrintable(message.member()),
+                     qPrintable(error.message()));
         else
-            qWarning("QDBusConnection: error: could not send %s message to service \"%s\"",
+            qWarning("QDBusConnection: error: could not send %s message to service \"%s\": %s",
                      message.type() == QDBusMessage::ReplyMessage ? "reply" :
                      message.type() == QDBusMessage::ErrorMessage ? "error" :
-                     "invalid", qPrintable(message.service()));
+                     "invalid", qPrintable(message.service()),
+                     qPrintable(error.message()));
+        lastError = error;
         return 0;
     }
@@ -1749 +1796 @@
 
     if (!QCoreApplication::instance() || sendMode == QDBus::Block) {
-        DBusMessage *msg = QDBusMessagePrivate::toDBusMessage(message);
+        QDBusError err;
+        DBusMessage *msg = QDBusMessagePrivate::toDBusMessage(message, &err);
         if (!msg) {
-            qWarning("QDBusConnection: error: could not send message to service \"%s\" path \"%s\" interface \"%s\" member \"%s\"",
+            qWarning("QDBusConnection: error: could not send message to service \"%s\" path \"%s\" interface \"%s\" member \"%s\": %s",
                      qPrintable(message.service()), qPrintable(message.path()),
-                     qPrintable(message.interface()), qPrintable(message.member()));
-            return QDBusMessage();
+                     qPrintable(message.interface()), qPrintable(message.member()),
+                     qPrintable(err.message()));
+            lastError = err;
+            return QDBusMessage::createError(err);
         }
 
@@ -1764 +1814 @@
 
         if (!!error) {
-            QDBusError qe = error;
-            lastError = qe;
-            return QDBusMessage::createError(qe);
+            lastError = err = error;
+            return QDBusMessage::createError(err);
         }
 
@@ -1776 +1825 @@
     } else { // use the event loop
         QDBusPendingCallPrivate *pcall = sendWithReplyAsync(message, timeout);
-        if (!pcall)
-            return QDBusMessage();
-
-        pcall->watcherHelper = new QDBusPendingCallWatcherHelper;
-        QEventLoop loop;
-        loop.connect(pcall->watcherHelper, SIGNAL(reply(QDBusMessage)), SLOT(quit()));
-        loop.connect(pcall->watcherHelper, SIGNAL(error(QDBusError,QDBusMessage)), SLOT(quit())); 
-
-        // enter the event loop and wait for a reply
-        loop.exec(QEventLoop::ExcludeUserInputEvents | QEventLoop::WaitForMoreEvents);
+        Q_ASSERT(pcall);
+
+        if (pcall->replyMessage.type() != QDBusMessage::InvalidMessage) {
+            pcall->watcherHelper = new QDBusPendingCallWatcherHelper;
+            QEventLoop loop;
+            loop.connect(pcall->watcherHelper, SIGNAL(reply(QDBusMessage)), SLOT(quit()));
+            loop.connect(pcall->watcherHelper, SIGNAL(error(QDBusError,QDBusMessage)), SLOT(quit()));
+
+            // enter the event loop and wait for a reply
+            loop.exec(QEventLoop::ExcludeUserInputEvents | QEventLoop::WaitForMoreEvents);
+        }
 
         QDBusMessage reply = pcall->replyMessage;
@@ -1841 +1891 @@
     }
 
-    DBusMessage *msg = QDBusMessagePrivate::toDBusMessage(message);
-    if (!msg) {
-        qWarning("QDBusConnection: error: could not send message to service \"%s\" path \"%s\" interface \"%s\" member \"%s\"",
-                 qPrintable(message.service()), qPrintable(message.path()),
-                 qPrintable(message.interface()), qPrintable(message.member()));
-        return 0;
-    }
-
     checkThread();
-    qDBusDebug() << QThread::currentThread() << "sending message (async):" << message;
-    DBusPendingCall *pending = 0;
     QDBusPendingCallPrivate *pcall = new QDBusPendingCallPrivate;
     pcall->sentMessage = message;
     pcall->ref = 0;
+
+    QDBusError error;
+    DBusMessage *msg = QDBusMessagePrivate::toDBusMessage(message, &error);
+    if (!msg) {
+        qWarning("QDBusConnection: error: could not send message to service \"%s\" path \"%s\" interface \"%s\" member \"%s\": %s",
+                 qPrintable(message.service()), qPrintable(message.path()),
+                 qPrintable(message.interface()), qPrintable(message.member()),
+                 qPrintable(error.message()));
+        pcall->replyMessage = QDBusMessage::createError(error);
+        lastError = error;
+        return pcall;
+    }
+
+    qDBusDebug() << QThread::currentThread() << "sending message (async):" << message;
+    DBusPendingCall *pending = 0;
 
     QDBusDispatchLocker locker(SendWithReplyAsyncAction, this);
@@ -1868 +1923 @@
         } else {
             // we're probably disconnected at this point
-            lastError = QDBusError(QDBusError::Disconnected, QLatin1String("Not connected to server"));
+            lastError = error = QDBusError(QDBusError::Disconnected, QLatin1String("Not connected to server"));
         }
     } else {
-        lastError = QDBusError(QDBusError::NoMemory, QLatin1String("Out of memory"));
+        lastError = error = QDBusError(QDBusError::NoMemory, QLatin1String("Out of memory"));
     }
 
     q_dbus_message_unref(msg);
-    pcall->replyMessage = QDBusMessage::createError(lastError);
+    pcall->replyMessage = QDBusMessage::createError(error);
     return pcall;
 }
@@ -1884 +1939 @@
 {
     QDBusPendingCallPrivate *pcall = sendWithReplyAsync(message, timeout);
-    if (!pcall)
-        return 0;
+    Q_ASSERT(pcall);
 
     // has it already finished (dispatched locally)?
@@ -1926 +1980 @@
 }
 
+bool QDBusConnectionPrivate::connectSignal(const QString &service,
+                                           const QString &path, const QString &interface, const QString &name,
+                                           const QStringList &argumentMatch, const QString &signature,
+                                           QObject *receiver, const char *slot)
+{
+    // check the slot
+    QDBusConnectionPrivate::SignalHook hook;
+    QString key;
+    QString name2 = name;
+    if (name2.isNull())
+        name2.detach();
+
+    hook.signature = signature;
+    if (!prepareHook(hook, key, service, path, interface, name, argumentMatch, receiver, slot, 0, false))
+        return false;           // don't connect
+
+    // avoid duplicating:
+    QDBusConnectionPrivate::SignalHookHash::ConstIterator it = signalHooks.find(key);
+    QDBusConnectionPrivate::SignalHookHash::ConstIterator end = signalHooks.constEnd();
+    for ( ; it != end && it.key() == key; ++it) {
+        const QDBusConnectionPrivate::SignalHook &entry = it.value();
+        if (entry.service == hook.service &&
+            entry.path == hook.path &&
+            entry.signature == hook.signature &&
+            entry.obj == hook.obj &&
+            entry.midx == hook.midx) {
+            // no need to compare the parameters if it's the same slot
+            return true;        // already there
+        }
+    }
+
+    connectSignal(key, hook);
+    return true;
+}
+
 void QDBusConnectionPrivate::connectSignal(const QString &key, const SignalHook &hook)
 {
     signalHooks.insertMulti(key, hook);
     connect(hook.obj, SIGNAL(destroyed(QObject*)), SLOT(objectDestroyed(QObject*)),
-            Qt::DirectConnection);
+            Qt::ConnectionType(Qt::DirectConnection | Qt::UniqueConnection));
 
     MatchRefCountHash::iterator it = matchRefCounts.find(hook.matchRule);
@@ -1953 +2042 @@
                      qPrintable(qerror.name()), qPrintable(qerror.message()));
             Q_ASSERT(false);
-        }
-    }
+        } else {
+            // Successfully connected the signal
+            // Do we need to watch for this name?
+            if (shouldWatchService(hook.service)) {
+                WatchedServicesHash::mapped_type &data = watchedServices[hook.service];
+                if (data.refcount) {
+                    // already watching
+                    ++data.refcount;
+                } else {
+                    // we need to watch for this service changing
+                    QString dbusServerService = QLatin1String(DBUS_SERVICE_DBUS);
+                    connectSignal(dbusServerService, QString(), QLatin1String(DBUS_INTERFACE_DBUS),
+                                  QLatin1String("NameOwnerChanged"), QStringList() << hook.service, QString(),
+                                  this, SLOT(_q_serviceOwnerChanged(QString,QString,QString)));
+                    data.owner = getNameOwnerNoCache(hook.service);
+                    qDBusDebug() << this << "Watching service" << hook.service << "for owner changes (current owner:"
+                            << data.owner << ")";
+                }
+            }
+        }
+    }
+}
+
+bool QDBusConnectionPrivate::disconnectSignal(const QString &service,
+                                              const QString &path, const QString &interface, const QString &name,
+                                              const QStringList &argumentMatch, const QString &signature,
+                                              QObject *receiver, const char *slot)
+{
+    // check the slot
+    QDBusConnectionPrivate::SignalHook hook;
+    QString key;
+    QString name2 = name;
+    if (name2.isNull())
+        name2.detach();
+
+    hook.signature = signature;
+    if (!prepareHook(hook, key, service, path, interface, name, argumentMatch, receiver, slot, 0, false))
+        return false;           // don't disconnect
+
+    // avoid duplicating:
+    QDBusConnectionPrivate::SignalHookHash::Iterator it = signalHooks.find(key);
+    QDBusConnectionPrivate::SignalHookHash::Iterator end = signalHooks.end();
+    for ( ; it != end && it.key() == key; ++it) {
+        const QDBusConnectionPrivate::SignalHook &entry = it.value();
+        if (entry.service == hook.service &&
+            entry.path == hook.path &&
+            entry.signature == hook.signature &&
+            entry.obj == hook.obj &&
+            entry.midx == hook.midx) {
+            // no need to compare the parameters if it's the same slot
+            disconnectSignal(it);
+            return true;        // it was there
+        }
+    }
+
+    // the slot was not found
+    return false;
 }
 
@@ -1961 +2105 @@
 {
     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;
@@ -2010 +2167 @@
 }
 
-void QDBusConnectionPrivate::connectRelay(const QString &service, const QString &owner,
+void QDBusConnectionPrivate::connectRelay(const QString &service,
                                           const QString &path, const QString &interface,
                                           QDBusAbstractInterface *receiver,
@@ -2020 +2177 @@
     QString key;
 
-    if (!prepareHook(hook, key, service, owner, path, interface, QString(), receiver, signal,
+    if (!prepareHook(hook, key, service, path, interface, QString(), QStringList(), receiver, signal,
                      QDBusAbstractInterface::staticMetaObject.methodCount(), true))
         return;                 // don't connect
@@ -2031 +2188 @@
         const SignalHook &entry = it.value();
         if (entry.service == hook.service &&
-            entry.owner == hook.owner &&
             entry.path == hook.path &&
             entry.signature == hook.signature &&
@@ -2042 +2198 @@
 }
 
-void QDBusConnectionPrivate::disconnectRelay(const QString &service, const QString &owner,
+void QDBusConnectionPrivate::disconnectRelay(const QString &service,
                                              const QString &path, const QString &interface,
                                              QDBusAbstractInterface *receiver,
@@ -2052 +2208 @@
     QString key;
 
-    if (!prepareHook(hook, key, service, owner, path, interface, QString(), receiver, signal,
+    if (!prepareHook(hook, key, service, path, interface, QString(), QStringList(), receiver, signal,
                      QDBusAbstractInterface::staticMetaObject.methodCount(), true))
         return;                 // don't connect
@@ -2063 +2219 @@
         const SignalHook &entry = it.value();
         if (entry.service == hook.service &&
-            entry.owner == hook.owner &&
             entry.path == hook.path &&
             entry.signature == hook.signature &&
@@ -2081 +2236 @@
     if (QDBusUtil::isValidUniqueConnectionName(serviceName))
         return serviceName;
-    if (!connection || !QDBusUtil::isValidBusName(serviceName))
+    if (!connection)
         return QString();
 
+    {
+        // acquire a read lock for the cache
+        QReadLocker locker(&lock);
+        WatchedServicesHash::ConstIterator it = watchedServices.constFind(serviceName);
+        if (it != watchedServices.constEnd())
+            return it->owner;
+    }
+
+    // not cached
+    return getNameOwnerNoCache(serviceName);
+}
+
+QString QDBusConnectionPrivate::getNameOwnerNoCache(const QString &serviceName)
+{
     QDBusMessage msg = QDBusMessage::createMethodCall(QLatin1String(DBUS_SERVICE_DBUS),
             QLatin1String(DBUS_PATH_DBUS), QLatin1String(DBUS_INTERFACE_DBUS),
             QLatin1String("GetNameOwner"));
+    QDBusMessagePrivate::setParametersValidated(msg, true);
     msg << serviceName;
     QDBusMessage reply = sendWithReply(msg, QDBus::Block);
@@ -2110 +2280 @@
                                                 QLatin1String(DBUS_INTERFACE_INTROSPECTABLE),
                                                 QLatin1String("Introspect"));
+    QDBusMessagePrivate::setParametersValidated(msg, true);
 
     QDBusMessage reply = sendWithReply(msg, QDBus::Block);