Convert generic engine plugin to be incremental.

10 files changed, 266 insertions, 390 deletions

diff --git a/src/network/bearer/qnetworkconfigmanager.cpp b/src/network/bearer/qnetworkconfigmanager.cpp
index 02cc652..6c0b17d 100644
--- a/src/network/bearer/qnetworkconfigmanager.cpp
+++ b/src/network/bearer/qnetworkconfigmanager.cpp
@@ -45,6 +45,7 @@
 #include "qnetworkconfigmanager_s60_p.h"
 #else
 #include "qnetworkconfigmanager_p.h"
+#include "qnetworksessionengine_p.h"
 #endif
 
 QT_BEGIN_NAMESPACE
@@ -234,28 +235,31 @@ QList<QNetworkConfiguration> QNetworkConfigurationManager::allConfigurations(QNe
 {
     QList<QNetworkConfiguration> result;
     QNetworkConfigurationManagerPrivate* conPriv = connManager();
-    QList<QString> cpsIdents = conPriv->accessPointConfigurations.keys();
-
-    //find all InternetAccessPoints
-    foreach( QString ii, cpsIdents) {
-        QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> p = 
-            conPriv->accessPointConfigurations.value(ii);
-        if ( (p->state & filter) == filter ) {
-            QNetworkConfiguration pt;
-            pt.d = conPriv->accessPointConfigurations.value(ii);
-            result << pt;
+
+    foreach (QNetworkSessionEngine *engine, conPriv->sessionEngines) {
+        QStringList cpsIdents = engine->accessPointConfigurations.keys();
+
+        //find all InternetAccessPoints
+        foreach (const QString &ii, cpsIdents) {
+            QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> p =
+                    engine->accessPointConfigurations.value(ii);
+            if ((p->state & filter) == filter) {
+                QNetworkConfiguration pt;
+                pt.d = engine->accessPointConfigurations.value(ii);
+                result << pt;
+            }
         }
-    }
 
-    //find all service networks
-    cpsIdents = conPriv->snapConfigurations.keys();
-    foreach( QString ii, cpsIdents) {
-        QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> p = 
-            conPriv->snapConfigurations.value(ii);
-        if ( (p->state & filter) == filter ) {
-            QNetworkConfiguration pt;
-            pt.d = conPriv->snapConfigurations.value(ii);
-            result << pt;
+        //find all service networks
+        cpsIdents = engine->snapConfigurations.keys();
+        foreach (const QString &ii, cpsIdents) {
+            QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> p =
+                    engine->snapConfigurations.value(ii);
+            if ((p->state & filter) == filter) {
+                QNetworkConfiguration pt;
+                pt.d = engine->snapConfigurations.value(ii);
+                result << pt;
+            }
         }
     }
 
@@ -271,15 +275,23 @@ QList<QNetworkConfiguration> QNetworkConfigurationManager::allConfigurations(QNe
 QNetworkConfiguration QNetworkConfigurationManager::configurationFromIdentifier(const QString& identifier) const
 {
     QNetworkConfigurationManagerPrivate* conPriv = connManager();
+
     QNetworkConfiguration item;
-    if (conPriv->accessPointConfigurations.contains(identifier))
-        item.d = conPriv->accessPointConfigurations.value(identifier);
-    else if (conPriv->snapConfigurations.contains(identifier))
-        item.d = conPriv->snapConfigurations.value(identifier);
-    else if (conPriv->userChoiceConfigurations.contains(identifier))
-        item.d = conPriv->userChoiceConfigurations.value(identifier);
-    return item;
 
+    foreach (QNetworkSessionEngine *engine, conPriv->sessionEngines) {
+        if (engine->accessPointConfigurations.contains(identifier))
+            item.d = engine->accessPointConfigurations.value(identifier);
+        else if (engine->snapConfigurations.contains(identifier))
+            item.d = engine->snapConfigurations.value(identifier);
+        else if (engine->userChoiceConfigurations.contains(identifier))
+            item.d = engine->userChoiceConfigurations.value(identifier);
+        else
+            continue;
+
+        return item;
+    }
+
+    return item;
 }
 
 /*!
diff --git a/src/network/bearer/qnetworkconfigmanager_p.cpp b/src/network/bearer/qnetworkconfigmanager_p.cpp
index f8e0d7b..09714e5 100644
--- a/src/network/bearer/qnetworkconfigmanager_p.cpp
+++ b/src/network/bearer/qnetworkconfigmanager_p.cpp
@@ -53,50 +53,34 @@ QT_BEGIN_NAMESPACE
 Q_GLOBAL_STATIC_WITH_ARGS(QFactoryLoader, loader,
                           (QBearerEngineFactoryInterface_iid, QLatin1String("/bearer")))
 
+QNetworkConfigurationManagerPrivate::~QNetworkConfigurationManagerPrivate()
+{
+    while (!sessionEngines.isEmpty())
+        delete sessionEngines.takeFirst();
+}
+
 void QNetworkConfigurationManagerPrivate::registerPlatformCapabilities()
 {
     capFlags = QNetworkConfigurationManager::ForcedRoaming;
 }
 
-void QNetworkConfigurationManagerPrivate::configurationAdded(QNetworkConfigurationPrivate *cpPriv, QNetworkSessionEngine *engine)
+void QNetworkConfigurationManagerPrivate::configurationAdded(QNetworkConfigurationPrivatePointer ptr)
 {
-    QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> ptr(new QNetworkConfigurationPrivate);
-
-    ptr.data()->isValid = cpPriv->isValid;
-    ptr.data()->name = cpPriv->name;
-    ptr.data()->id = cpPriv->id;
-    ptr.data()->state = cpPriv->state;
-    ptr.data()->type = cpPriv->type;
-    ptr.data()->roamingSupported = cpPriv->roamingSupported;
-    ptr.data()->purpose = cpPriv->purpose;
-    ptr.data()->internet = cpPriv->internet;
-
-    accessPointConfigurations.insert(cpPriv->id, ptr);
-    configurationEngine.insert(cpPriv->id, engine);
-
     if (!firstUpdate) {
         QNetworkConfiguration item;
         item.d = ptr;
         emit configurationAdded(item);
     }
 
-    if (ptr.data()->state == QNetworkConfiguration::Active) {
+    if (ptr->state == QNetworkConfiguration::Active) {
         ++onlineConfigurations;
         if (!firstUpdate && onlineConfigurations == 1)
             emit onlineStateChanged(true);
     }
 }
 
-void QNetworkConfigurationManagerPrivate::configurationRemoved(const QString &id)
+void QNetworkConfigurationManagerPrivate::configurationRemoved(QNetworkConfigurationPrivatePointer ptr)
 {
-    if (!accessPointConfigurations.contains(id))
-        return;
-
-    QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> ptr =
-        accessPointConfigurations.take(id);
-
-    configurationEngine.remove(id);
-
     ptr.data()->isValid = false;
 
     if (!firstUpdate) {
@@ -112,57 +96,34 @@ void QNetworkConfigurationManagerPrivate::configurationRemoved(const QString &id
     }
 }
 
-void QNetworkConfigurationManagerPrivate::configurationChanged(QNetworkConfigurationPrivate *cpPriv)
+void QNetworkConfigurationManagerPrivate::configurationChanged(QNetworkConfigurationPrivatePointer ptr)
 {
-    if (!accessPointConfigurations.contains(cpPriv->id))
-        return;
-
-    QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> ptr =
-        accessPointConfigurations.value(cpPriv->id);
-
-    if (ptr.data()->isValid != cpPriv->isValid ||
-        ptr.data()->name != cpPriv->name ||
-        ptr.data()->id != cpPriv->id ||
-        ptr.data()->state != cpPriv->state ||
-        ptr.data()->type != cpPriv->type ||
-        ptr.data()->roamingSupported != cpPriv->roamingSupported ||
-        ptr.data()->purpose != cpPriv->purpose ||
-        ptr.data()->internet != cpPriv->internet) {
-
-        const QNetworkConfiguration::StateFlags oldState = ptr.data()->state;
-
-        ptr.data()->isValid = cpPriv->isValid;
-        ptr.data()->name = cpPriv->name;
-        ptr.data()->id = cpPriv->id;
-        ptr.data()->state = cpPriv->state;
-        ptr.data()->type = cpPriv->type;
-        ptr.data()->roamingSupported = cpPriv->roamingSupported;
-        ptr.data()->purpose = cpPriv->purpose;
-        ptr.data()->internet = cpPriv->internet;
+    if (!firstUpdate) {
+        QNetworkConfiguration item;
+        item.d = ptr;
+        emit configurationChanged(item);
+    }
 
-        if (!firstUpdate) {
-            QNetworkConfiguration item;
-            item.d = ptr;
-            emit configurationChanged(item);
-        }
+    qDebug() << "Need to recalculate online state.";
+    QNetworkConfiguration::StateFlags oldState = ptr->state;
 
-        if (ptr.data()->state == QNetworkConfiguration::Active && oldState != ptr.data()->state) {
-            // configuration went online
-            ++onlineConfigurations;
-            if (!firstUpdate && onlineConfigurations == 1)
-                emit onlineStateChanged(true);
-        } else if (ptr.data()->state != QNetworkConfiguration::Active && oldState == QNetworkConfiguration::Active) {
-            // configuration went offline
-            --onlineConfigurations;
-            if (!firstUpdate && onlineConfigurations == 0)
-                emit onlineStateChanged(false);
-        }
+    if (ptr->state == QNetworkConfiguration::Active && oldState != ptr->state) {
+        // configuration went online
+        ++onlineConfigurations;
+        if (!firstUpdate && onlineConfigurations == 1)
+            emit onlineStateChanged(true);
+    } else if (ptr->state != QNetworkConfiguration::Active && oldState == QNetworkConfiguration::Active) {
+        // configuration went offline
+        --onlineConfigurations;
+        if (!firstUpdate && onlineConfigurations == 0)
+            emit onlineStateChanged(false);
     }
 }
 
 void QNetworkConfigurationManagerPrivate::updateInternetServiceConfiguration()
 {
-    if (!snapConfigurations.contains(QLatin1String("Internet Service Network"))) {
+#if 0
+    if (!generic->snapConfigurations.contains(QLatin1String("Internet Service Network"))) {
         QNetworkConfigurationPrivate *serviceNetwork = new QNetworkConfigurationPrivate;
         serviceNetwork->name = tr("Internet");
         serviceNetwork->isValid = true;
@@ -172,7 +133,7 @@ void QNetworkConfigurationManagerPrivate::updateInternetServiceConfiguration()
 
         QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> ptr(serviceNetwork);
 
-        snapConfigurations.insert(serviceNetwork->id, ptr);
+        generic->snapConfigurations.insert(serviceNetwork->id, ptr);
 
         if (!firstUpdate) {
             QNetworkConfiguration item;
@@ -182,15 +143,15 @@ void QNetworkConfigurationManagerPrivate::updateInternetServiceConfiguration()
     }
 
     QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> ptr =
-        snapConfigurations.value(QLatin1String("Internet Service Network"));
+        generic->snapConfigurations.value(QLatin1String("Internet Service Network"));
 
     QList<QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> > serviceNetworkMembers;
 
     QHash<QString, QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> >::const_iterator i =
-        accessPointConfigurations.constBegin();
+        generic->accessPointConfigurations.constBegin();
 
     QNetworkConfiguration::StateFlags state = QNetworkConfiguration::Defined;
-    while (i != accessPointConfigurations.constEnd()) {
+    while (i != generic->accessPointConfigurations.constEnd()) {
         QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> child = i.value();
 
         if (child.data()->internet && ((child.data()->state & QNetworkConfiguration::Defined)
@@ -212,186 +173,92 @@ void QNetworkConfigurationManagerPrivate::updateInternetServiceConfiguration()
         item.d = ptr;
         emit configurationChanged(item);
     }
+#endif
 }
 
 void QNetworkConfigurationManagerPrivate::updateConfigurations()
 {
     if (firstUpdate) {
-        updateState = NotUpdating;
         onlineConfigurations = 0;
 
         QFactoryLoader *l = loader();
         QStringList keys = l->keys();
 
-#if defined (Q_OS_DARWIN)
-        coreWifi = 0;
         if (keys.contains(QLatin1String("corewlan"))) {
             QBearerEnginePlugin *coreWlanPlugin =
                 qobject_cast<QBearerEnginePlugin *>(l->instance(QLatin1String("corewlan")));
             if (coreWlanPlugin) {
-                coreWifi = coreWlanPlugin->create(QLatin1String("corewlan"));
+                QNetworkSessionEngine *coreWifi = coreWlanPlugin->create(QLatin1String("corewlan"));
                 if (coreWifi) {
-                    connect(coreWifi, SIGNAL(configurationsChanged()),
-                            this, SLOT(updateConfigurations()));
+                    sessionEngines.append(coreWifi);
                 }
             }
         }
-#else
-#ifdef BACKEND_NM
-        nmWifi = 0;
+
         if (keys.contains(QLatin1String("networkmanager"))) {
             QBearerEnginePlugin *nmPlugin =
                 qobject_cast<QBearerEnginePlugin *>(l->instance(QLatin1String("networkmanager")));
             if (nmPlugin) {
-                nmWifi = nmPlugin->create(QLatin1String("networkmanager"));
+                QNetworkSessionEngine *nmWifi = nmPlugin->create(QLatin1String("networkmanager"));
                 if (nmWifi) {
-                    connect(nmWifi, SIGNAL(configurationsChanged()),
-                            this, SLOT(updateConfigurations()));
+                    sessionEngines.append(nmWifi);
                 }
             }
         }
-#endif
 
-        generic = 0;
         if (keys.contains(QLatin1String("generic"))) {
             QBearerEnginePlugin *genericPlugin =
                 qobject_cast<QBearerEnginePlugin *>(l->instance(QLatin1String("generic")));
             if (genericPlugin) {
-                generic = genericPlugin->create(QLatin1String("generic"));
+                QNetworkSessionEngine *generic = genericPlugin->create(QLatin1String("generic"));
                 if (generic) {
-                    connect(generic, SIGNAL(configurationsChanged()),
-                            this, SLOT(updateConfigurations()));
+                    sessionEngines.append(generic);
+                    connect(generic, SIGNAL(updateCompleted()),
+                            this, SIGNAL(configurationUpdateComplete()));
+                    connect(generic, SIGNAL(configurationAdded(QNetworkConfigurationPrivatePointer)),
+                            this, SLOT(configurationAdded(QNetworkConfigurationPrivatePointer)));
+                    connect(generic, SIGNAL(configurationRemoved(QNetworkConfigurationPrivatePointer)),
+                            this, SLOT(configurationRemoved(QNetworkConfigurationPrivatePointer)));
+                    connect(generic, SIGNAL(configurationChanged(QNetworkConfigurationPrivatePointer)),
+                            this, SLOT(configurationChanged(QNetworkConfigurationPrivatePointer)));
                 }
             }
         }
-#endif
 
-#ifdef Q_OS_WIN
-        nla = 0;
         if (keys.contains(QLatin1String("nla"))) {
             QBearerEnginePlugin *nlaPlugin =
                 qobject_cast<QBearerEnginePlugin *>(l->instance(QLatin1String("nla")));
             if (nlaPlugin) {
-                qDebug() << "creating nla backend";
-                nla = nlaPlugin->create(QLatin1String("nla"));
+                QNetworkSessionEngine *nla = nlaPlugin->create(QLatin1String("nla"));
                 if (nla) {
-                    connect(nla, SIGNAL(configurationsChanged()),
-                            this, SLOT(updateConfigurations()));
+                    sessionEngines.append(nla);
                 }
             }
         }
-#endif
 
-#ifdef Q_OS_WIN32
-        nativeWifi = 0;
         if (keys.contains(QLatin1String("nativewifi"))) {
             QBearerEnginePlugin *nativeWifiPlugin =
                 qobject_cast<QBearerEnginePlugin *>(l->instance(QLatin1String("nativewifi")));
             if (nativeWifiPlugin) {
-                qDebug() << "Creating native wifi backend";
-                nativeWifi = nativeWifiPlugin->create(QLatin1String("nativewifi"));
+                QNetworkSessionEngine *nativeWifi = nativeWifiPlugin->create(QLatin1String("nativewifi"));
                 if (nativeWifi) {
-                    connect(nativeWifi, SIGNAL(configurationsChanged()),
-                            this, SLOT(updateConfigurations()));
+                    sessionEngines.append(nativeWifi);
 
                     capFlags |= QNetworkConfigurationManager::CanStartAndStopInterfaces;
                 }
             }
         }
-#endif
     }
 
     QNetworkSessionEngine *engine = qobject_cast<QNetworkSessionEngine *>(sender());
-    if (updateState & Updating && engine) {
-#if defined (Q_OS_DARWIN)
-        if (engine == coreWifi)
-            updateState &= ~CoreWifiUpdating;
-#else
-#if defined(BACKEND_NM)
-        if (engine == nmWifi)
-            updateState &= ~NmUpdating;
-        if (engine == generic)
-            updateState &= ~GenericUpdating;
-#else
-        if (engine == generic)
-            updateState &= ~GenericUpdating;
-#endif
-#endif
-
-#ifdef Q_OS_WIN
-        else if (engine == nla)
-            updateState &= ~NlaUpdating;
-#ifdef Q_OS_WIN32
-        else if (engine == nativeWifi)
-            updateState &= ~NativeWifiUpdating;
-#endif
-#endif
-    }
-    QList<QNetworkSessionEngine *> engines;
-    if (firstUpdate) {
-#if defined (Q_OS_DARWIN)
-        if (coreWifi)
-            engines << coreWifi;
-#else
-#if defined(BACKEND_NM)
-        if (nmWifi)
-            engines << nmWifi;
-        if (generic)
-            engines << generic;
-#else
-        if (generic)
-            engines << generic;
-#endif
-#endif
-
-#ifdef Q_OS_WIN
-        if (nla)
-            engines << nla;
-#ifdef Q_OS_WIN32
-        if (nativeWifi)
-            engines << nativeWifi;
-#endif
-#endif
-    } else if (engine) {
-        engines << engine;
-    }
-
-    while (!engines.isEmpty()) {
-        engine = engines.takeFirst();
-
-        bool ok;
-        QList<QNetworkConfigurationPrivate *> foundConfigurations = engine->getConfigurations(&ok);
-
-        // Find removed configurations.
-        QList<QString> removedIdentifiers = configurationEngine.keys();
-        for (int i = 0; i < foundConfigurations.count(); ++i)
-            removedIdentifiers.removeOne(foundConfigurations.at(i)->id);
-
-        // Update or add configurations.
-        while (!foundConfigurations.isEmpty()) {
-            QNetworkConfigurationPrivate *cpPriv = foundConfigurations.takeFirst();
-
-            if (accessPointConfigurations.contains(cpPriv->id))
-                configurationChanged(cpPriv);
-            else
-                configurationAdded(cpPriv, engine);
-
-            delete cpPriv;
-        }
-
-        // Remove configurations.
-        while (!removedIdentifiers.isEmpty()) {
-            const QString id = removedIdentifiers.takeFirst();
-
-            if (configurationEngine.value(id) == engine)
-                configurationRemoved(id);
-        }
+    if (!updatingEngines.isEmpty() && engine) {
+        int index = sessionEngines.indexOf(engine);
+        if (index >= 0)
+            updatingEngines.remove(index);
     }
 
-    updateInternetServiceConfiguration();
-
-    if (updateState == Updating) {
-        updateState = NotUpdating;
+    if (updating && updatingEngines.isEmpty()) {
+        updating = false;
         emit configurationUpdateComplete();
     }
 
@@ -407,22 +274,25 @@ void QNetworkConfigurationManagerPrivate::updateConfigurations()
 */
 QNetworkConfiguration QNetworkConfigurationManagerPrivate::defaultConfiguration()
 {
-    QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> firstActive;
-    QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> firstDiscovered;
+    QNetworkConfigurationPrivatePointer firstActive;
+    QNetworkConfigurationPrivatePointer firstDiscovered;
 
-    QHash<QString, QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> >::const_iterator i =
-        accessPointConfigurations.constBegin();
-    while (i != accessPointConfigurations.constEnd()) {
-        QNetworkConfigurationPrivate *priv = i.value().data();
+    foreach (QNetworkSessionEngine *engine, sessionEngines) {
+        QHash<QString, QNetworkConfigurationPrivatePointer>::const_iterator i =
+                engine->accessPointConfigurations.constBegin();
 
-        if (!firstActive && priv->isValid &&
-            (priv->state & QNetworkConfiguration::Active) == QNetworkConfiguration::Active)
-            firstActive = i.value();
-        if (!firstDiscovered && priv->isValid &&
-            (priv->state & QNetworkConfiguration::Discovered) == QNetworkConfiguration::Discovered)
-            firstDiscovered = i.value();
+        while (i != engine->accessPointConfigurations.constEnd()) {
+            QNetworkConfigurationPrivatePointer priv = i.value();
 
-        ++i;
+            if (!firstActive && priv->isValid &&
+                (priv->state & QNetworkConfiguration::Active) == QNetworkConfiguration::Active)
+                firstActive = priv;
+            if (!firstDiscovered && priv->isValid &&
+                (priv->state & QNetworkConfiguration::Discovered) == QNetworkConfiguration::Discovered)
+                firstDiscovered = priv;
+
+            ++i;
+        }
     }
 
     QNetworkConfiguration item;
@@ -437,42 +307,12 @@ QNetworkConfiguration QNetworkConfigurationManagerPrivate::defaultConfiguration(
 
 void QNetworkConfigurationManagerPrivate::performAsyncConfigurationUpdate()
 {
-    updateState = Updating;
-#if defined (Q_OS_DARWIN)
-    if (coreWifi) {
-        updateState |= CoreWifiUpdating;
-        coreWifi->requestUpdate();
-    }
-#else
-#if defined(BACKEND_NM)
-    if (nmWifi) {
-        updateState |= NmUpdating;
-        nmWifi->requestUpdate();
-    }
-    if (generic) {
-        updateState |= GenericUpdating;
-        generic->requestUpdate();
-    }
-#else
-    if (generic) {
-        updateState |= GenericUpdating;
-        generic->requestUpdate();
-    }
-#endif
-#endif
-#ifdef Q_OS_WIN
-    if (nla) {
-        updateState |= NlaUpdating;
-        nla->requestUpdate();
-    }
-#endif
+    updating = true;
 
-#ifdef Q_OS_WIN32
-    if (nativeWifi) {
-        updateState |= NativeWifiUpdating;
-        nativeWifi->requestUpdate();
+    for (int i = 0; i < sessionEngines.count(); ++i) {
+        updatingEngines.insert(i);
+        sessionEngines.at(i)->requestUpdate();
     }
-#endif
 }
 
 QT_END_NAMESPACE
diff --git a/src/network/bearer/qnetworkconfigmanager_p.h b/src/network/bearer/qnetworkconfigmanager_p.h
index 95358bc..27a0252 100644
--- a/src/network/bearer/qnetworkconfigmanager_p.h
+++ b/src/network/bearer/qnetworkconfigmanager_p.h
@@ -56,20 +56,9 @@
 #include "qnetworkconfigmanager.h"
 #include "qnetworkconfiguration_p.h"
 
-#include <QHash>
-#include <QStringList>
-
 QT_BEGIN_NAMESPACE
 
-#ifdef BEARER_ENGINE
 class QNetworkSessionEngine;
-class QGenericEngine;
-class QNlaEngine;
-class QNativeWifiEngine;
-class QNmWifiEngine;
-class QCoreWlanEngine;
-#endif
-
 
 class QNetworkConfigurationManagerPrivate : public QObject
 {
@@ -82,22 +71,7 @@ public:
         updateConfigurations();
     }
 
-    virtual ~QNetworkConfigurationManagerPrivate() 
-    {
-        QList<QString> configIdents = snapConfigurations.keys();
-        foreach(const QString oldIface, configIdents) {
-            QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = snapConfigurations.take(oldIface);
-            priv->isValid = false;
-            priv->id.clear();
-        }
-
-        configIdents = accessPointConfigurations.keys();
-        foreach(const QString oldIface, configIdents) {
-            QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> priv = accessPointConfigurations.take(oldIface);
-            priv->isValid = false;
-            priv->id.clear();
-        }
-    }
+    virtual ~QNetworkConfigurationManagerPrivate();
 
     QNetworkConfiguration defaultConfiguration();
 
@@ -106,12 +80,6 @@ public:
 
     void performAsyncConfigurationUpdate();
 
-    //this table contains an up to date list of all configs at any time.
-    //it must be updated if configurations change, are added/removed or
-    //the members of ServiceNetworks change
-    QHash<QString, QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> > accessPointConfigurations;
-    QHash<QString, QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> > snapConfigurations;
-    QHash<QString, QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> > userChoiceConfigurations;
 #ifdef BEARER_ENGINE
     QHash<QString, QNetworkSessionEngine *> configurationEngine;
 #endif
@@ -135,41 +103,21 @@ private:
 #endif
 
 #ifdef BEARER_ENGINE
-    QNetworkSessionEngine *generic;
-#ifdef Q_OS_WIN
-    QNetworkSessionEngine *nla;
-#ifndef Q_OS_WINCE
-    QNetworkSessionEngine *nativeWifi;
-#endif
-#endif
-#ifdef BACKEND_NM
-    QNetworkSessionEngine *nmWifi;
-#endif
-#ifdef Q_OS_DARWIN
-    QNetworkSessionEngine *coreWifi;
-#endif
+public:
+    QList<QNetworkSessionEngine *> sessionEngines;
 
+private:
     uint onlineConfigurations;
 
-    enum EngineUpdate {
-        NotUpdating = 0x00,
-        Updating = 0x01,
-        GenericUpdating = 0x02,
-        NlaUpdating = 0x04,
-        NativeWifiUpdating = 0x08,
-        NmUpdating = 0x20,
-        CoreWifiUpdating = 0x40,
-    };
-    Q_DECLARE_FLAGS(EngineUpdateState, EngineUpdate)
-
-    EngineUpdateState updateState;
+    bool updating;
+    QSet<int> updatingEngines;
 #endif
 
 private Q_SLOTS:
 #ifdef BEARER_ENGINE
-    void configurationAdded(QNetworkConfigurationPrivate *cpPriv, QNetworkSessionEngine *engine);
-    void configurationRemoved(const QString &id);
-    void configurationChanged(QNetworkConfigurationPrivate *cpPriv);
+    void configurationAdded(QNetworkConfigurationPrivatePointer ptr);
+    void configurationRemoved(QNetworkConfigurationPrivatePointer ptr);
+    void configurationChanged(QNetworkConfigurationPrivatePointer ptr);
 #endif
 };
 
diff --git a/src/network/bearer/qnetworkconfiguration_p.h b/src/network/bearer/qnetworkconfiguration_p.h
index f00bcfa..8e69248 100644
--- a/src/network/bearer/qnetworkconfiguration_p.h
+++ b/src/network/bearer/qnetworkconfiguration_p.h
@@ -59,6 +59,7 @@
 
 QT_BEGIN_NAMESPACE
 
+typedef QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> QNetworkConfigurationPrivatePointer;
 class QNetworkConfigurationPrivate : public QSharedData
 {
 public:
@@ -89,7 +90,7 @@ public:
     bool internet;
 #endif
 
-    QList<QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> > serviceNetworkMembers;
+    QList<QNetworkConfigurationPrivatePointer> serviceNetworkMembers;
     QNetworkInterface serviceInterface;
 
 private:
diff --git a/src/network/bearer/qnetworksessionengine.cpp b/src/network/bearer/qnetworksessionengine.cpp
index 9e6839e..0aa9d19 100644
--- a/src/network/bearer/qnetworksessionengine.cpp
+++ b/src/network/bearer/qnetworksessionengine.cpp
@@ -50,6 +50,17 @@ QNetworkSessionEngine::QNetworkSessionEngine(QObject *parent)
 
 QNetworkSessionEngine::~QNetworkSessionEngine()
 {
+    foreach (const QString &oldIface, snapConfigurations.keys()) {
+        QNetworkConfigurationPrivatePointer priv = snapConfigurations.take(oldIface);
+        priv->isValid = false;
+        priv->id.clear();
+    }
+
+    foreach (const QString &oldIface, accessPointConfigurations.keys()) {
+        QNetworkConfigurationPrivatePointer priv = accessPointConfigurations.take(oldIface);
+        priv->isValid = false;
+        priv->id.clear();
+    }
 }
 
 #include "moc_qnetworksessionengine_p.cpp"
diff --git a/src/network/bearer/qnetworksessionengine_p.h b/src/network/bearer/qnetworksessionengine_p.h
index 9fbd4ac..0145976 100644
--- a/src/network/bearer/qnetworksessionengine_p.h
+++ b/src/network/bearer/qnetworksessionengine_p.h
@@ -53,14 +53,19 @@
 // We mean it.
 //
 
+#include "qnetworkconfiguration_p.h"
+
 #include <QtCore/qobject.h>
 #include <QtCore/qglobal.h>
 #include <QtCore/qlist.h>
 #include <QtCore/qstring.h>
+#include <QtCore/qhash.h>
+#include <QtCore/qsharedpointer.h>
 
 QT_BEGIN_NAMESPACE
 
-class QNetworkConfigurationPrivate;
+class QNetworkConfiguration;
+
 class Q_NETWORK_EXPORT QNetworkSessionEngine : public QObject
 {
     Q_OBJECT
@@ -76,7 +81,6 @@ public:
     QNetworkSessionEngine(QObject *parent = 0);
     virtual ~QNetworkSessionEngine();
 
-    virtual QList<QNetworkConfigurationPrivate *> getConfigurations(bool *ok = 0) = 0;
     virtual QString getInterfaceFromId(const QString &id) = 0;
     virtual bool hasIdentifier(const QString &id) = 0;
 
@@ -87,8 +91,21 @@ public:
 
     virtual void requestUpdate() = 0;
 
+public:
+    //this table contains an up to date list of all configs at any time.
+    //it must be updated if configurations change, are added/removed or
+    //the members of ServiceNetworks change
+    QHash<QString, QNetworkConfigurationPrivatePointer> accessPointConfigurations;
+    QHash<QString, QNetworkConfigurationPrivatePointer> snapConfigurations;
+    QHash<QString, QNetworkConfigurationPrivatePointer> userChoiceConfigurations;
+
 Q_SIGNALS:
-    void configurationsChanged();
+    void configurationAdded(QNetworkConfigurationPrivatePointer config);
+    void configurationRemoved(QNetworkConfigurationPrivatePointer config);
+    void configurationChanged(QNetworkConfigurationPrivatePointer config);
+
+    void updateCompleted();
+
     void connectionError(const QString &id, QNetworkSessionEngine::ConnectionError error);
 };
 
diff --git a/src/plugins/bearer/generic/qgenericengine.cpp b/src/plugins/bearer/generic/qgenericengine.cpp
index 4be27ba..11dfb3e 100644
--- a/src/plugins/bearer/generic/qgenericengine.cpp
+++ b/src/plugins/bearer/generic/qgenericengine.cpp
@@ -125,21 +125,58 @@ static QString qGetInterfaceType(const QString &interface)
 QGenericEngine::QGenericEngine(QObject *parent)
 :   QNetworkSessionEngine(parent)
 {
-    connect(&pollTimer, SIGNAL(timeout()), this, SIGNAL(configurationsChanged()));
+    connect(&pollTimer, SIGNAL(timeout()), this, SLOT(doRequestUpdate()));
     pollTimer.setInterval(10000);
+    doRequestUpdate();
 }
 
 QGenericEngine::~QGenericEngine()
 {
 }
 
-QList<QNetworkConfigurationPrivate *> QGenericEngine::getConfigurations(bool *ok)
+QString QGenericEngine::getInterfaceFromId(const QString &id)
+{
+    return configurationInterface.value(id.toUInt());
+}
+
+bool QGenericEngine::hasIdentifier(const QString &id)
+{
+    return configurationInterface.contains(id.toUInt());
+}
+
+QString QGenericEngine::bearerName(const QString &id)
+{
+    QString interface = getInterfaceFromId(id);
+
+    if (interface.isEmpty())
+        return QString();
+
+    return qGetInterfaceType(interface);
+}
+
+void QGenericEngine::connectToId(const QString &id)
+{
+    emit connectionError(id, OperationNotSupported);
+}
+
+void QGenericEngine::disconnectFromId(const QString &id)
+{
+    emit connectionError(id, OperationNotSupported);
+}
+
+void QGenericEngine::requestUpdate()
 {
-    if (ok)
-        *ok = true;
+    pollTimer.stop();
+    QTimer::singleShot(0, this, SLOT(doRequestUpdate()));
+}
 
-    QList<QNetworkConfigurationPrivate *> foundConfigurations;
+QGenericEngine *QGenericEngine::instance()
+{
+    return genericEngine();
+}
 
+void QGenericEngine::doRequestUpdate()
+{
     // Immediately after connecting with a wireless access point
     // QNetworkInterface::allInterfaces() will sometimes return an empty list. Calling it again a
     // second time results in a non-empty list. If we loose interfaces we will end up removing
@@ -148,6 +185,8 @@ QList<QNetworkConfigurationPrivate *> QGenericEngine::getConfigurations(bool *ok
     if (interfaces.isEmpty())
         interfaces = QNetworkInterface::allInterfaces();
 
+    QStringList previous = accessPointConfigurations.keys();
+
     // create configuration for each interface
     while (!interfaces.isEmpty()) {
         QNetworkInterface interface = interfaces.takeFirst();
@@ -163,71 +202,77 @@ QList<QNetworkConfigurationPrivate *> QGenericEngine::getConfigurations(bool *ok
         if (qGetInterfaceType(interface.name()) == QLatin1String("WLAN"))
             continue;
 
-        QNetworkConfigurationPrivate *cpPriv = new QNetworkConfigurationPrivate;
-        const QString humanReadableName = interface.humanReadableName();
-        cpPriv->name = humanReadableName.isEmpty() ? interface.name() : humanReadableName;
-        cpPriv->isValid = true;
-
         uint identifier;
         if (interface.index())
-            identifier = qHash(QLatin1String("NLA:") + QString::number(interface.index()));
+            identifier = qHash(QLatin1String("generic:") + QString::number(interface.index()));
         else
-            identifier = qHash(QLatin1String("NLA:") + interface.hardwareAddress());
+            identifier = qHash(QLatin1String("generic:") + interface.hardwareAddress());
+
+        const QString id = QString::number(identifier);
 
-        cpPriv->id = QString::number(identifier);
-        cpPriv->state = QNetworkConfiguration::Discovered;
-        cpPriv->type = QNetworkConfiguration::InternetAccessPoint;
+        previous.removeAll(id);
+
+        QString name = interface.humanReadableName();
+        if (name.isEmpty())
+            name = interface.name();
+
+        QNetworkConfiguration::StateFlags state = QNetworkConfiguration::Discovered;
         if (interface.flags() & QNetworkInterface::IsUp)
-            cpPriv->state |= QNetworkConfiguration::Active;
+            state |= QNetworkConfiguration::Active;
 
-        configurationInterface[identifier] = interface.name();
+        if (accessPointConfigurations.contains(id)) {
+            QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> ptr =
+                accessPointConfigurations.value(id);
 
-        foundConfigurations.append(cpPriv);
-    }
+            bool changed = false;
 
-    pollTimer.start();
+            if (!ptr->isValid) {
+                ptr->isValid = true;
+                changed = true;
+            }
 
-    return foundConfigurations;
-}
+            if (ptr->name != name) {
+                ptr->name = name;
+                changed = true;
+            }
 
-QString QGenericEngine::getInterfaceFromId(const QString &id)
-{
-    return configurationInterface.value(id.toUInt());
-}
+            if (ptr->id != id) {
+                ptr->id = id;
+                changed = true;
+            }
 
-bool QGenericEngine::hasIdentifier(const QString &id)
-{
-    return configurationInterface.contains(id.toUInt());
-}
+            if (ptr->state != state) {
+                ptr->state = state;
+                changed = true;
+            }
 
-QString QGenericEngine::bearerName(const QString &id)
-{
-    QString interface = getInterfaceFromId(id);
+            if (changed)
+                emit configurationChanged(ptr);
+        } else {
+            QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> ptr(new QNetworkConfigurationPrivate);
 
-    if (interface.isEmpty())
-        return QString();
+            ptr->name = name;
+            ptr->isValid = true;
+            ptr->id = id;
+            ptr->state = state;
+            ptr->type = QNetworkConfiguration::InternetAccessPoint;
 
-    return qGetInterfaceType(interface);
-}
+            accessPointConfigurations.insert(id, ptr);
 
-void QGenericEngine::connectToId(const QString &id)
-{
-    emit connectionError(id, OperationNotSupported);
-}
+            emit configurationAdded(ptr);
+        }
+    }
 
-void QGenericEngine::disconnectFromId(const QString &id)
-{
-    emit connectionError(id, OperationNotSupported);
-}
+    while (!previous.isEmpty()) {
+        QExplicitlySharedDataPointer<QNetworkConfigurationPrivate> ptr =
+            accessPointConfigurations.take(previous.takeFirst());
 
-void QGenericEngine::requestUpdate()
-{
-    emit configurationsChanged();
-}
+        emit configurationRemoved(ptr);
+    }
 
-QGenericEngine *QGenericEngine::instance()
-{
-    return genericEngine();
+    pollTimer.start();
+
+    emit updateCompleted();
 }
 
 QT_END_NAMESPACE
diff --git a/src/plugins/bearer/generic/qgenericengine.h b/src/plugins/bearer/generic/qgenericengine.h
index 9923a9b..62f964a 100644
--- a/src/plugins/bearer/generic/qgenericengine.h
+++ b/src/plugins/bearer/generic/qgenericengine.h
@@ -59,7 +59,6 @@ public:
     QGenericEngine(QObject *parent = 0);
     ~QGenericEngine();
 
-    QList<QNetworkConfigurationPrivate *> getConfigurations(bool *ok = 0);
     QString getInterfaceFromId(const QString &id);
     bool hasIdentifier(const QString &id);
 
@@ -72,6 +71,9 @@ public:
 
     static QGenericEngine *instance();
 
+private Q_SLOTS:
+    void doRequestUpdate();
+
 private:
     QMap<uint, QString> configurationInterface;
     QTimer pollTimer;
diff --git a/src/plugins/bearer/networkmanager/qnmwifiengine.cpp b/src/plugins/bearer/networkmanager/qnmwifiengine.cpp
index 4a814ec..b215023 100644
--- a/src/plugins/bearer/networkmanager/qnmwifiengine.cpp
+++ b/src/plugins/bearer/networkmanager/qnmwifiengine.cpp
@@ -112,7 +112,7 @@ QString QNmWifiEngine::getNameForConfiguration(QNetworkManagerInterfaceDevice *d
 }
 
 
-QList<QNetworkConfigurationPrivate *> QNmWifiEngine::getConfigurations(bool *ok)
+QList<QNetworkConfigurationPrivatePointer> QNmWifiEngine::getConfigurations(bool *ok)
 {
 //    qWarning() << Q_FUNC_INFO << updated;
     if (ok)
@@ -133,7 +133,7 @@ QList<QNetworkConfigurationPrivate *> QNmWifiEngine::getConfigurations(bool *ok)
         //add access points
         updated = true;
     }
-    return foundConfigurations;
+    return QList<QNetworkConfigurationPrivatePointer>(); //foundConfigurations;
 }
 
 void QNmWifiEngine::findConnections()
@@ -411,7 +411,7 @@ bool QNmWifiEngine::hasIdentifier(const QString &id)
 {
     if (configurationInterface.contains(id))
         return true;
-    foreach (QNetworkConfigurationPrivate *cpPriv, getConfigurations()) {
+    foreach (QNetworkConfigurationPrivatePointer cpPriv, getConfigurations()) {
         if (cpPriv->id == id)
             return true;
     }
@@ -506,7 +506,7 @@ void QNmWifiEngine::requestUpdate()
     updated = false;
     knownSsids.clear();
     availableAccessPoints.clear();
-    emitConfigurationsChanged();
+    //emitConfigurationsChanged();
 }
 
 QNmWifiEngine *QNmWifiEngine::instance()
diff --git a/src/plugins/bearer/networkmanager/qnmwifiengine.h b/src/plugins/bearer/networkmanager/qnmwifiengine.h
index 4d514e7..d651ef4 100644
--- a/src/plugins/bearer/networkmanager/qnmwifiengine.h
+++ b/src/plugins/bearer/networkmanager/qnmwifiengine.h
@@ -80,7 +80,7 @@ public:
     QNmWifiEngine(QObject *parent = 0);
     ~QNmWifiEngine();
 
-    QList<QNetworkConfigurationPrivate *> getConfigurations(bool *ok = 0);
+    QList<QNetworkConfigurationPrivatePointer> getConfigurations(bool *ok = 0);
     QString getInterfaceFromId(const QString &id);
     bool hasIdentifier(const QString &id);
 
@@ -94,7 +94,7 @@ public:
     static QNmWifiEngine *instance();
 
     QStringList knownSsids;
-    inline void emitConfigurationsChanged() { emit configurationsChanged(); }
+    //inline void emitConfigurationsChanged() { emit configurationsChanged(); }
     QNetworkConfigurationPrivate * addAccessPoint(const QString &, QDBusObjectPath );
 
     QStringList getConnectionPathForId(const QString &uuid);