MCL/sf/mw/qt: comparison src/dbus/qdbusintegrator.cpp

equal deleted inserted replaced

-:41300fa6a67c
+:3b1da2848fc7
 /****************************************************************************
 **
-** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtDBus module of the Qt Toolkit.
 **
 server_d->serverConnection(retval);
 }
 } // 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 QStringList &argMatch, const QString & /*signature*/)
 {
 QString result = QLatin1String("type='signal',");
 QString keyValue = QLatin1String("%1='%2',");
 QDBusConnectionPrivate *d = static_cast<QDBusConnectionPrivate *>(data);
 if (d->mode == QDBusConnectionPrivate::InvalidMode)
 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 QDBusMessage amsg = QDBusMessagePrivate::fromDBusMessage(message);
-qDBusDebug() << QThread::currentThread() << "got message:" << amsg;
+qDBusDebug() << d << "got message:" << amsg;
 return d->handleMessage(amsg) ?
 DBUS_HANDLER_RESULT_HANDLED :
 DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 }
 // do we create a reply? Only if the caller is waiting for a reply and one hasn't been sent
 // yet.
 if (msg.isReplyRequired() && !msg.isDelayedReply()) {
 if (!fail) {
 // normal reply
-qDBusDebug() << QThread::currentThread() << "Automatically sending reply:" << outputArgs;
+qDBusDebug() << this << "Automatically sending reply:" << outputArgs;
 send(msg.createReply(outputArgs));
 } else {
 // generate internal error
 qWarning("Internal error: Failed to deliver message");
 send(msg.createErrorReply(QDBusError::InternalError,
 #endif
 QDBusMetaTypeId::init();
 rootNode.flags = 0;
-watchedServiceNames[QLatin1String(DBUS_SERVICE_DBUS)] = 1;
 }
 QDBusConnectionPrivate::~QDBusConnectionPrivate()
 {
 if (thread() && thread() != QThread::currentThread())
 void QDBusConnectionPrivate::_q_serviceOwnerChanged(const QString &name,
 const QString &oldOwner, const QString &newOwner)
 {
 Q_UNUSED(oldOwner);
 QDBusWriteLocker locker(UpdateSignalHookOwnerAction, this);
-QMutableHashIterator<QString, SignalHook> it(signalHooks);
+WatchedServicesHash::Iterator it = watchedServices.find(name);
-it.toFront();
+if (it == watchedServices.end())
-while (it.hasNext())
+return;
-if (it.next().value().service == name)
+if (oldOwner != it->owner)
-it.value().owner = newOwner;
+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;
 }
 int QDBusConnectionPrivate::findSlot(QObject* obj, const QByteArray &normalizedName,
 QList<int> &params)
 {
 return midx;
 }
 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)
 {
 {}
 return false;
 }
 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
 for (int i = 1; i < hook.params.count(); ++i)
 if (hook.params.at(i) != QDBusMetaTypeId::message)
 hook.signature += QLatin1String( QDBusMetaType::typeToSignature( hook.params.at(i) ) );
 }
-hook.matchRule = buildMatchRule(service, owner, path, interface, mname, argMatch, hook.signature);
+hook.matchRule = buildMatchRule(service, path, interface, mname, argMatch, hook.signature);
 return true;                // connect to this signal
 }
 void QDBusConnectionPrivate::sendError(const QDBusMessage &msg, QDBusError::ErrorType code)
 {
 SignalHookHash::const_iterator end = signalHooks.constEnd();
 //qDebug("looking for: %s", path.toLocal8Bit().constData());
 //qDBusDebug() << signalHooks.keys();
 for ( ; it != end && it.key() == key; ++it) {
 const SignalHook &hook = it.value();
-if (!hook.owner.isNull() && hook.owner != msg.service())
+if (!hook.service.isEmpty()) {
-continue;
+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;
 if (!hook.signature.isEmpty() && hook.signature != msg.signature())
 continue;
 if (hook.signature.isEmpty() && !hook.signature.isNull() && !msg.signature().isEmpty())
 } else {
 qWarning("QDBusConnectionPrivate::setConnection: Unable to get base service");
 }
 QString busService = QLatin1String(DBUS_SERVICE_DBUS);
-connectSignal(busService, QString(), QString(), QString(), QLatin1String("NameAcquired"), QStringList(), QString(),
+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(), QString(), QLatin1String("NameLost"), QStringList(), QString(),
+connectSignal(busService, QString(), QString(), QLatin1String("NameLost"), QStringList(), QString(),
 this, SLOT(unregisterService(QString)));
 q_dbus_connection_add_filter(connection, qDBusSignalFilter, this, 0);
-//qDebug("base service: %s", service);
+qDBusDebug() << this << ": connected successfully";
 // schedule a dispatch:
 QMetaObject::invokeMethod(this, "doDispatch", Qt::QueuedConnection);
 }
 // decode the message
 DBusMessage *reply = q_dbus_pending_call_steal_reply(call->pending);
 msg = QDBusMessagePrivate::fromDBusMessage(reply);
 q_dbus_message_unref(reply);
 }
-qDBusDebug() << QThread::currentThread() << "got message reply (async):" << msg;
+qDBusDebug() << connection << "got message reply (async):" << msg;
 // Check if the reply has the expected signature
 call->checkReceivedSignature();
 if (!call->receiver.isNull() && call->methodIdx != -1 && msg.type() == QDBusMessage::ReplyMessage) {
 return 0;
 }
 q_dbus_message_set_no_reply(msg, true); // the reply would not be delivered to anything
-qDBusDebug() << QThread::currentThread() << "sending message (no reply):" << message;
+qDBusDebug() << this << "sending message (no reply):" << message;
 checkThread();
 bool isOk = q_dbus_connection_send(connection, msg, 0);
 int serial = 0;
 if (isOk)
 serial = q_dbus_message_get_serial(msg);
 qPrintable(err.message()));
 lastError = err;
 return QDBusMessage::createError(err);
 }
-qDBusDebug() << QThread::currentThread() << "sending message (blocking):" << message;
+qDBusDebug() << this << "sending message (blocking):" << message;
 QDBusErrorInternal error;
 DBusMessage *reply = q_dbus_connection_send_with_reply_and_block(connection, msg, timeout, error);
 q_dbus_message_unref(msg);
 return QDBusMessage::createError(err);
 }
 QDBusMessage amsg = QDBusMessagePrivate::fromDBusMessage(reply);
 q_dbus_message_unref(reply);
-qDBusDebug() << QThread::currentThread() << "got message reply (blocking):" << amsg;
+qDBusDebug() << this << "got message reply (blocking):" << amsg;
 return amsg;
 } else { // use the event loop
 QDBusPendingCallPrivate *pcall = sendWithReplyAsync(message, timeout);
 Q_ASSERT(pcall);
-if (pcall->replyMessage.type() != QDBusMessage::InvalidMessage) {
+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()));
 }
 }
 QDBusMessage QDBusConnectionPrivate::sendWithReplyLocal(const QDBusMessage &message)
 {
-qDBusDebug() << QThread::currentThread() << "sending message via local-loop:" << message;
+qDBusDebug() << this << "sending message via local-loop:" << message;
 QDBusMessage localCallMsg = QDBusMessagePrivate::makeLocal(*this, message);
 bool handled = handleMessage(localCallMsg);
 if (!handled) {
 QDBusError(QDBusError::InternalError,
 QLatin1String("local-loop message cannot have delayed replies")));
 }
 // there is a reply
-qDBusDebug() << QThread::currentThread() << "got message via local-loop:" << localReplyMsg;
+qDBusDebug() << this << "got message via local-loop:" << localReplyMsg;
 return localReplyMsg;
 }
 QDBusPendingCallPrivate *QDBusConnectionPrivate::sendWithReplyAsync(const QDBusMessage &message,
 int timeout)
 pcall->replyMessage = QDBusMessage::createError(error);
 lastError = error;
 return pcall;
 }
-qDBusDebug() << QThread::currentThread() << "sending message (async):" << message;
+qDBusDebug() << this << "sending message (async):" << message;
 DBusPendingCall *pending = 0;
 QDBusDispatchLocker locker(SendWithReplyAsyncAction, this);
 if (q_dbus_connection_send_with_reply(connection, msg, &pending, timeout)) {
 if (pending) {
 }
 return 1;
 }
-bool QDBusConnectionPrivate::connectSignal(const QString &service, const QString &owner,
+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
 QString name2 = name;
 if (name2.isNull())
 name2.detach();
 hook.signature = signature;
-if (!prepareHook(hook, key, service, owner, path, interface, name, argumentMatch, receiver, slot, 0, false))
+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.owner == hook.owner &&
 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
 Q_ASSERT(false);
 } else {
 // Successfully connected the signal
 // Do we need to watch for this name?
 if (shouldWatchService(hook.service)) {
-WatchedServicesHash::Iterator it = watchedServiceNames.find(hook.service);
+WatchedServicesHash::mapped_type &data = watchedServices[hook.service];
-if (it != watchedServiceNames.end()) {
+if (data.refcount) {
 // already watching
-++it.value();
+++data.refcount;
 } else {
 // we need to watch for this service changing
 QString dbusServerService = QLatin1String(DBUS_SERVICE_DBUS);
-connectSignal(dbusServerService, dbusServerService, QString(), QLatin1String(DBUS_INTERFACE_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 << ")";
 }
 }
 }
 }
 }
 QString name2 = name;
 if (name2.isNull())
 name2.detach();
 hook.signature = signature;
-if (!prepareHook(hook, key, service, QString(), path, interface, name, argumentMatch, receiver, slot, 0, false))
+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.owner == hook.owner &&
 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
 QDBusConnectionPrivate::SignalHookHash::Iterator
 QDBusConnectionPrivate::disconnectSignal(SignalHookHash::Iterator &it)
 {
 const SignalHook &hook = it.value();
-WatchedServicesHash::Iterator sit = watchedServiceNames.find(hook.service);
+WatchedServicesHash::Iterator sit = watchedServices.find(hook.service);
-if (sit != watchedServiceNames.end()) {
+if (sit != watchedServices.end()) {
-if (sit.value() == 1) {
+if (sit.value().refcount == 1) {
-watchedServiceNames.erase(sit);
+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();
+--sit.value().refcount;
 }
 }
 bool erase = false;
 MatchRefCountHash::iterator i = matchRefCounts.find(hook.matchRule);
 this, SLOT(relaySignal(QObject*,const QMetaObject*,int,QVariantList)),
 Qt::DirectConnection);
 }
 }
-void QDBusConnectionPrivate::connectRelay(const QString &service, const QString &owner,
+void QDBusConnectionPrivate::connectRelay(const QString &service,
 const QString &path, const QString &interface,
 QDBusAbstractInterface *receiver,
 const char *signal)
 {
 // this function is called by QDBusAbstractInterface when one of its signals is connected
 // we set up a relay from D-Bus into it
 SignalHook hook;
 QString key;
-if (!prepareHook(hook, key, service, owner, path, interface, QString(), QStringList(), receiver, signal,
+if (!prepareHook(hook, key, service, path, interface, QString(), QStringList(), receiver, signal,
 QDBusAbstractInterface::staticMetaObject.methodCount(), true))
 return;                 // don't connect
 // add it to our list:
 QDBusWriteLocker locker(ConnectRelayAction, this);
 SignalHookHash::ConstIterator it = signalHooks.find(key);
 SignalHookHash::ConstIterator end = signalHooks.constEnd();
 for ( ; it != end && it.key() == key; ++it) {
 const SignalHook &entry = it.value();
 if (entry.service == hook.service &&
-entry.owner == hook.owner &&
 entry.path == hook.path &&
 entry.signature == hook.signature &&
 entry.obj == hook.obj &&
 entry.midx == hook.midx)
 return;             // already there, no need to re-add
 }
 connectSignal(key, hook);
 }
-void QDBusConnectionPrivate::disconnectRelay(const QString &service, const QString &owner,
+void QDBusConnectionPrivate::disconnectRelay(const QString &service,
 const QString &path, const QString &interface,
 QDBusAbstractInterface *receiver,
 const char *signal)
 {
 // this function is called by QDBusAbstractInterface when one of its signals is disconnected
 // we remove relay from D-Bus into it
 SignalHook hook;
 QString key;
-if (!prepareHook(hook, key, service, owner, path, interface, QString(), QStringList(), receiver, signal,
+if (!prepareHook(hook, key, service, path, interface, QString(), QStringList(), receiver, signal,
 QDBusAbstractInterface::staticMetaObject.methodCount(), true))
 return;                 // don't connect
 // remove it from our list:
 QDBusWriteLocker locker(DisconnectRelayAction, this);
 SignalHookHash::Iterator it = signalHooks.find(key);
 SignalHookHash::Iterator end = signalHooks.end();
 for ( ; it != end && it.key() == key; ++it) {
 const SignalHook &entry = it.value();
 if (entry.service == hook.service &&
-entry.owner == hook.owner &&
 entry.path == hook.path &&
 entry.signature == hook.signature &&
 entry.obj == hook.obj &&
 entry.midx == hook.midx) {
 // found it
 QString QDBusConnectionPrivate::getNameOwner(const QString& serviceName)
 {
 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;

branch	RCL_3
changeset 4	3b1da2848fc7
parent 3	41300fa6a67c
child 5	d3bac044e0f0