Wrap network access to enable testing in Nokia plugin

This enables subsequent testing of the stack (from C++) without being
connected to the network.

Change-Id: I55ad5ece9c323ec82a493d059f1418f68169c5e6
Task-number: QTBUG-25416
Reviewed-by: Alex Wilson <alex.wilson@nokia.com>

19 files changed, 361 insertions, 163 deletions

diff --git a/src/plugins/geoservices/nokia/nokia.pro b/src/plugins/geoservices/nokia/nokia.pro
index 248863bd..a5b7b6d1 100644
--- a/src/plugins/geoservices/nokia/nokia.pro
+++ b/src/plugins/geoservices/nokia/nokia.pro
@@ -26,7 +26,10 @@ HEADERS += \
             qgeoroutexmlparser.h \
             qgeoroutingmanagerengine_nokia.h \
             qgeoserviceproviderplugin_nokia.h \
-            marclanguagecodes.h
+            marclanguagecodes.h \
+            qgeonetworkaccessmanager.h \
+            qgeointrinsicnetworkaccessmanager.h
+
 
 SOURCES += \
             qgeocodereply_nokia.cpp \
@@ -39,7 +42,8 @@ SOURCES += \
             qgeoroutereply_nokia.cpp \
             qgeoroutexmlparser.cpp \
             qgeoroutingmanagerengine_nokia.cpp \
-            qgeoserviceproviderplugin_nokia.cpp
+            qgeoserviceproviderplugin_nokia.cpp \
+            qgeointrinsicnetworkaccessmanager.cpp
 
 include(placesv1/placesv1.pri)
 include(placesv2/placesv2.pri)
diff --git a/src/plugins/geoservices/nokia/placesv1/qplacerestmanager.cpp b/src/plugins/geoservices/nokia/placesv1/qplacerestmanager.cpp
index a33c7abe..de9c3e7b 100644
--- a/src/plugins/geoservices/nokia/placesv1/qplacerestmanager.cpp
+++ b/src/plugins/geoservices/nokia/placesv1/qplacerestmanager.cpp
@@ -48,6 +48,7 @@
 
 #include "qplacerestmanager.h"
 #include "qplacecategoriesrepository.h"
+#include "../qgeointrinsicnetworkaccessmanager.h"
 
 #include <QtNetwork>
 #include <QHash>
@@ -94,11 +95,11 @@ QPlaceRestManager *QPlaceRestManager::mInstance = NULL;
     Constructor.
 */
 QPlaceRestManager::QPlaceRestManager(QObject *parent)
-:   QObject(parent), placeServer(QLatin1String(placesServerUrl)),
+:   QObject(parent), mManager(new QGeoIntrinsicNetworkAccessManager(this)),
+    placeServer(QLatin1String(placesServerUrl)),
     searchServer(QLatin1String(searchServerUrl))
 {
     mLocales << QLocale();
-    mManager = new QNetworkAccessManager(this);
 }
 
 /*!
@@ -113,11 +114,15 @@ QPlaceRestManager *QPlaceRestManager::instance()
 }
 
 /*!
-    Sets the proxy used for requests.
+    Sets the network access manager used for requests.
 */
-void QPlaceRestManager::setProxy(const QNetworkProxy &proxy)
+void QPlaceRestManager::setNetworkAccessManager(QGeoNetworkAccessManager* manager)
 {
-    mManager->setProxy(proxy);
+    if (manager) {
+        delete mManager;
+        mManager = manager;
+        mManager->setParent(this);
+    }
 }
 
 /*!
diff --git a/src/plugins/geoservices/nokia/placesv1/qplacerestmanager.h b/src/plugins/geoservices/nokia/placesv1/qplacerestmanager.h
index 7fdcd5c1..bea2bee4 100644
--- a/src/plugins/geoservices/nokia/placesv1/qplacerestmanager.h
+++ b/src/plugins/geoservices/nokia/placesv1/qplacerestmanager.h
@@ -51,8 +51,6 @@
 
 #include <QObject>
 
-#include <QtNetwork/QNetworkProxy>
-#include <QtNetwork/QNetworkAccessManager>
 #include <QtNetwork/QNetworkReply>
 #include <QtLocation/QPlaceContentRequest>
 
@@ -61,6 +59,8 @@
 
 QT_BEGIN_NAMESPACE
 
+class QGeoNetworkAccessManager;
+
 class QPlaceRestManager : public QObject
 {
     Q_OBJECT
@@ -68,7 +68,7 @@ class QPlaceRestManager : public QObject
 public:
     static QPlaceRestManager *instance();
 
-    void setProxy(const QNetworkProxy &proxy);
+    void setNetworkAccessManager(QGeoNetworkAccessManager* networkManager);
 
     QPlaceRestReply *sendPlaceRequest(const QString &placeId);
     QPlaceRestReply *sendPlaceImagesRequest(const QString &placeId, const QPlaceContentRequest &params);
@@ -96,7 +96,7 @@ private:
     QByteArray createLanguageString() const;
 
 private:
-    QNetworkAccessManager *mManager;
+    QGeoNetworkAccessManager *mManager;
     static QPlaceRestManager *mInstance;
     QString placeServer;
     QString searchServer;
diff --git a/src/plugins/geoservices/nokia/qgeocodingmanagerengine_nokia.cpp b/src/plugins/geoservices/nokia/qgeocodingmanagerengine_nokia.cpp
index 3513abf7..a8488ac6 100644
--- a/src/plugins/geoservices/nokia/qgeocodingmanagerengine_nokia.cpp
+++ b/src/plugins/geoservices/nokia/qgeocodingmanagerengine_nokia.cpp
@@ -49,39 +49,27 @@
 #include "qgeocodingmanagerengine_nokia.h"
 #include "qgeocodereply_nokia.h"
 #include "marclanguagecodes.h"
+#include "qgeonetworkaccessmanager.h"
 
 #include <qgeoaddress.h>
 #include <qgeocoordinate.h>
-#include <QNetworkProxy>
-#include <QNetworkProxyFactory>
 #include <QUrl>
 #include <QMap>
 #include <QStringList>
 
 QT_BEGIN_NAMESPACE
 
-QGeocodingManagerEngineNokia::QGeocodingManagerEngineNokia(const QMap<QString, QVariant> &parameters, QGeoServiceProvider::Error *error, QString *errorString)
-        : QGeocodingManagerEngine(parameters),
-        m_host("loc.desktop.maps.svc.ovi.com")
+QGeocodingManagerEngineNokia::QGeocodingManagerEngineNokia(
+        QGeoNetworkAccessManager* networkManager,
+        const QMap<QString, QVariant> &parameters,
+        QGeoServiceProvider::Error *error,
+        QString *errorString)
+        : QGeocodingManagerEngine(parameters)
+        , m_networkManager(networkManager)
+        , m_host("loc.desktop.maps.svc.ovi.com")
 {
-    m_networkManager = new QNetworkAccessManager(this);
-
-    if (parameters.contains("proxy")) {
-        QString proxy = parameters.value("proxy").toString();
-        if (!proxy.isEmpty() && proxy.toLower() != QLatin1String("system")) {
-            QUrl proxyUrl(proxy);
-            if (proxyUrl.isValid()) {
-                m_networkManager->setProxy(QNetworkProxy(QNetworkProxy::HttpProxy,
-                    proxyUrl.host(),
-                    proxyUrl.port(8080),
-                    proxyUrl.userName(),
-                    proxyUrl.password()));
-            }
-        } else if (!proxy.isEmpty()) {
-            if (QNetworkProxy::applicationProxy().type() == QNetworkProxy::NoProxy)
-                QNetworkProxyFactory::setUseSystemConfiguration(true);
-        }
-    }
+    Q_ASSERT(networkManager);
+    m_networkManager->setParent(this);
 
     if (parameters.contains("geocoding.host")) {
         QString host = parameters.value("geocoding.host").toString();
diff --git a/src/plugins/geoservices/nokia/qgeocodingmanagerengine_nokia.h b/src/plugins/geoservices/nokia/qgeocodingmanagerengine_nokia.h
index eeddc269..447965ef 100644
--- a/src/plugins/geoservices/nokia/qgeocodingmanagerengine_nokia.h
+++ b/src/plugins/geoservices/nokia/qgeocodingmanagerengine_nokia.h
@@ -54,17 +54,20 @@
 #include <qgeoserviceprovider.h>
 #include <qgeocodingmanagerengine.h>
 
-#include <QNetworkAccessManager>
+
 #include <QLocale>
 
 
 QT_BEGIN_NAMESPACE
 
+class QGeoNetworkAccessManager;
+
 class QGeocodingManagerEngineNokia : public QGeocodingManagerEngine
 {
     Q_OBJECT
 public:
-    QGeocodingManagerEngineNokia(const QMap<QString, QVariant> &parameters,
+    QGeocodingManagerEngineNokia(QGeoNetworkAccessManager* networkManager,
+                                 const QMap<QString, QVariant> &parameters,
                                  QGeoServiceProvider::Error *error,
                                  QString *errorString);
     ~QGeocodingManagerEngineNokia();
@@ -89,7 +92,7 @@ private:
     QString languageToMarc(QLocale::Language language);
     QString getAuthenticationString() const;
 
-    QNetworkAccessManager *m_networkManager;
+    QGeoNetworkAccessManager *m_networkManager;
     QString m_host;
     QString m_token;
     QString m_applicationId;
diff --git a/src/plugins/geoservices/nokia/qgeointrinsicnetworkaccessmanager.cpp b/src/plugins/geoservices/nokia/qgeointrinsicnetworkaccessmanager.cpp
new file mode 100644
index 00000000..4f5d4810
--- /dev/null
+++ b/src/plugins/geoservices/nokia/qgeointrinsicnetworkaccessmanager.cpp
@@ -0,0 +1,97 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the QtLocation module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this
+** file. Please review the following information to ensure the GNU Lesser
+** General Public License version 2.1 requirements 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qgeointrinsicnetworkaccessmanager.h"
+
+#include <QDebug>
+#include <QVariant>
+#include <QNetworkProxy>
+#include <QNetworkAccessManager>
+
+QGeoIntrinsicNetworkAccessManager::QGeoIntrinsicNetworkAccessManager(QObject *parent)
+: QGeoNetworkAccessManager(parent)
+, m_networkManager(new QNetworkAccessManager(this))
+{
+}
+
+
+void QGeoIntrinsicNetworkAccessManager::configure(const QMap<QString, QVariant> &parameters)
+{
+    QString proxy = parameters.value(QStringLiteral("proxy")).toString();
+    if (proxy.isEmpty() && !m_customProxyToken.isEmpty())
+        proxy = parameters.value(m_customProxyToken).toString();
+
+    if (!proxy.isEmpty()) {
+        if (proxy.toLower() != QStringLiteral("system")) {
+            QUrl proxyUrl(proxy);
+            if (proxyUrl.isValid()) {
+                qDebug() << "Setting proxy to " << proxyUrl.toString();
+                m_networkManager->setProxy(
+                    QNetworkProxy(QNetworkProxy::HttpProxy,
+                    proxyUrl.host(),
+                    proxyUrl.port(8080),
+                    proxyUrl.userName(),
+                    proxyUrl.password()));
+            }
+        } else if (QNetworkProxy::applicationProxy().type() == QNetworkProxy::NoProxy) {
+            QNetworkProxyFactory::setUseSystemConfiguration(true);
+            qDebug() << "Setting system proxy.";
+        }
+    } else {
+        qDebug() << "No proxy parameter specified.";
+    }
+}
+
+
+void QGeoIntrinsicNetworkAccessManager::setCustomProxyToken(const QString& token)
+{
+    m_customProxyToken = token;
+}
+
+QNetworkReply* QGeoIntrinsicNetworkAccessManager::get(const QNetworkRequest& request)
+{
+    return m_networkManager->get(request);
+}
+
+QNetworkReply *QGeoIntrinsicNetworkAccessManager::post(const QNetworkRequest &request, const QByteArray &data)
+{
+    return m_networkManager->post(request, data);
+}
diff --git a/src/plugins/geoservices/nokia/qgeointrinsicnetworkaccessmanager.h b/src/plugins/geoservices/nokia/qgeointrinsicnetworkaccessmanager.h
new file mode 100644
index 00000000..7e99182e
--- /dev/null
+++ b/src/plugins/geoservices/nokia/qgeointrinsicnetworkaccessmanager.h
@@ -0,0 +1,68 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the QtLocation module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this
+** file. Please review the following information to ensure the GNU Lesser
+** General Public License version 2.1 requirements 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGEOINTRINSICNETWORKACCESSMANAGER_H
+#define QGEOINTRINSICNETWORKACCESSMANAGER_H
+
+#include "qgeonetworkaccessmanager.h"
+
+#include <QMap>
+
+QT_BEGIN_NAMESPACE
+
+class QNetworkAccessManager;
+
+class QGeoIntrinsicNetworkAccessManager : public QGeoNetworkAccessManager
+{
+public:
+    explicit QGeoIntrinsicNetworkAccessManager(QObject *parent = 0);
+    void configure(const QMap<QString, QVariant> &parameters);
+    void setCustomProxyToken(const QString& token);
+    virtual QNetworkReply* get(const QNetworkRequest& request);
+    virtual QNetworkReply *post(const QNetworkRequest &request, const QByteArray &data);
+private:
+    QString m_customProxyToken;
+    QNetworkAccessManager* m_networkManager;
+};
+
+QT_END_NAMESPACE
+
+#endif // QGEOINTRINSICNETWORKACCESSMANAGER_H
diff --git a/src/plugins/geoservices/nokia/qgeonetworkaccessmanager.h b/src/plugins/geoservices/nokia/qgeonetworkaccessmanager.h
new file mode 100644
index 00000000..73a4c208
--- /dev/null
+++ b/src/plugins/geoservices/nokia/qgeonetworkaccessmanager.h
@@ -0,0 +1,67 @@
+/****************************************************************************
+**
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the QtLocation module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** This file may be used under the terms of the GNU Lesser General Public
+** License version 2.1 as published by the Free Software Foundation and
+** appearing in the file LICENSE.LGPL included in the packaging of this
+** file. Please review the following information to ensure the GNU Lesser
+** General Public License version 2.1 requirements 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.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QGEONETWORKACCESSMANAGER_H
+#define QGEONETWORKACCESSMANAGER_H
+
+#include <QObject>
+
+QT_BEGIN_NAMESPACE
+
+class QNetworkReply;
+class QNetworkRequest;
+class QByteArray;
+
+class QGeoNetworkAccessManager : public QObject
+{
+    Q_OBJECT
+public:
+    virtual ~QGeoNetworkAccessManager() {}
+    virtual QNetworkReply* get(const QNetworkRequest& request) = 0;
+    virtual QNetworkReply *post(const QNetworkRequest &request, const QByteArray &data) = 0;
+
+protected:
+    QGeoNetworkAccessManager(QObject* parent) : QObject(parent) {}
+};
+
+QT_END_NAMESPACE
+
+#endif // QGEONETWORKACCESSMANAGER_H
diff --git a/src/plugins/geoservices/nokia/qgeoroutingmanagerengine_nokia.cpp b/src/plugins/geoservices/nokia/qgeoroutingmanagerengine_nokia.cpp
index ae8b7ef0..8fa7d33a 100644
--- a/src/plugins/geoservices/nokia/qgeoroutingmanagerengine_nokia.cpp
+++ b/src/plugins/geoservices/nokia/qgeoroutingmanagerengine_nokia.cpp
@@ -48,40 +48,27 @@
 
 #include "qgeoroutingmanagerengine_nokia.h"
 #include "qgeoroutereply_nokia.h"
+#include "qgeonetworkaccessmanager.h"
 
 #include <QStringList>
-#include <QNetworkProxy>
-#include <QNetworkProxyFactory>
 #include <QUrl>
+#include <QLocale>
 #include <qgeoboundingbox.h>
 
 QT_BEGIN_NAMESPACE
 
-QGeoRoutingManagerEngineNokia::QGeoRoutingManagerEngineNokia(const QMap<QString, QVariant> &parameters, QGeoServiceProvider::Error *error, QString *errorString)
+QGeoRoutingManagerEngineNokia::QGeoRoutingManagerEngineNokia(
+        QGeoNetworkAccessManager* networkManager,
+        const QMap<QString, QVariant> &parameters,
+        QGeoServiceProvider::Error *error,
+        QString *errorString)
         : QGeoRoutingManagerEngine(parameters)
+        , m_networkManager(networkManager)
         , m_host(QStringLiteral("route.nlp.nokia.com"))
+
 {
-    m_networkManager = new QNetworkAccessManager(this);
-
-    if (parameters.contains(QStringLiteral("proxy")) || parameters.contains(QStringLiteral("routing.proxy"))) {
-        QString proxy = parameters.value("proxy").toString();
-        if (proxy.isEmpty())
-            proxy = parameters.value(QStringLiteral("routing.proxy")).toString();
-
-        if (!proxy.isEmpty() && proxy.toLower() != QStringLiteral("system")) {
-            QUrl proxyUrl(proxy);
-            if (proxyUrl.isValid()) {
-                m_networkManager->setProxy(QNetworkProxy(QNetworkProxy::HttpProxy,
-                    proxyUrl.host(),
-                    proxyUrl.port(8080),
-                    proxyUrl.userName(),
-                    proxyUrl.password()));
-            }
-        } else if (!proxy.isEmpty()) {
-            if (QNetworkProxy::applicationProxy().type() == QNetworkProxy::NoProxy)
-                QNetworkProxyFactory::setUseSystemConfiguration(true);
-        }
-    }
+    Q_ASSERT(networkManager);
+    m_networkManager->setParent(this);
 
     if (parameters.contains(QStringLiteral("routing.host"))) {
         QString host = parameters.value(QStringLiteral("routing.host")).toString();
@@ -89,6 +76,7 @@ QGeoRoutingManagerEngineNokia::QGeoRoutingManagerEngineNokia(const QMap<QString,
             m_host = host;
     }
 
+
     m_appId = parameters.value(QStringLiteral("app_id")).toString();
     m_token = parameters.value(QStringLiteral("token")).toString();
 
diff --git a/src/plugins/geoservices/nokia/qgeoroutingmanagerengine_nokia.h b/src/plugins/geoservices/nokia/qgeoroutingmanagerengine_nokia.h
index db880d8b..0dc93fee 100644
--- a/src/plugins/geoservices/nokia/qgeoroutingmanagerengine_nokia.h
+++ b/src/plugins/geoservices/nokia/qgeoroutingmanagerengine_nokia.h
@@ -53,15 +53,17 @@
 
 #include <qgeoserviceprovider.h>
 #include <qgeoroutingmanagerengine.h>
-#include <QNetworkAccessManager>
 
 QT_BEGIN_NAMESPACE
 
+class QGeoNetworkAccessManager;
+
 class QGeoRoutingManagerEngineNokia : public QGeoRoutingManagerEngine
 {
     Q_OBJECT
 public:
-    QGeoRoutingManagerEngineNokia(const QMap<QString, QVariant> &parameters,
+    QGeoRoutingManagerEngineNokia(QGeoNetworkAccessManager* networkInterface,
+                                  const QMap<QString, QVariant> &parameters,
                                   QGeoServiceProvider::Error *error,
                                   QString *errorString);
     ~QGeoRoutingManagerEngineNokia();
@@ -83,7 +85,7 @@ private:
                                QGeoRouteRequest::TravelModes travelModes) const;
     static QString trimDouble(double degree, int decimalDigits = 10);
 
-    QNetworkAccessManager *m_networkManager;
+    QGeoNetworkAccessManager *m_networkManager;
     QString m_host;
     QString m_appId;
     QString m_token;
diff --git a/src/plugins/geoservices/nokia/qgeoserviceproviderplugin_nokia.cpp b/src/plugins/geoservices/nokia/qgeoserviceproviderplugin_nokia.cpp
index b23f313c..43cbb8fc 100644
--- a/src/plugins/geoservices/nokia/qgeoserviceproviderplugin_nokia.cpp
+++ b/src/plugins/geoservices/nokia/qgeoserviceproviderplugin_nokia.cpp
@@ -53,12 +53,14 @@
 #include "qgeotiledmappingmanagerengine_nokia.h"
 #include "qplacemanagerengine_nokiav1.h"
 #include "qplacemanagerengine_nokiav2.h"
+#include "qgeointrinsicnetworkaccessmanager.h"
 
 #include <QtPlugin>
 #include <QNetworkProxy>
 
 QT_BEGIN_NAMESPACE
 
+
 QGeoServiceProviderFactoryNokia::QGeoServiceProviderFactoryNokia()
     : m_informedAboutUsageTerms(false)
 {}
@@ -71,7 +73,10 @@ QGeocodingManagerEngine* QGeoServiceProviderFactoryNokia::createGeocodingManager
 {
     informOnceAboutUsageTermsIfNecessary(parameters);
 
-    return new QGeocodingManagerEngineNokia(parameters, error, errorString);
+    QGeoIntrinsicNetworkAccessManager* networkManager = new QGeoIntrinsicNetworkAccessManager();
+    networkManager->configure(parameters);
+
+    return new QGeocodingManagerEngineNokia(networkManager, parameters, error, errorString);
 }
 
 QGeoMappingManagerEngine* QGeoServiceProviderFactoryNokia::createMappingManagerEngine(const QMap<QString, QVariant> &parameters,
@@ -80,7 +85,11 @@ QGeoMappingManagerEngine* QGeoServiceProviderFactoryNokia::createMappingManagerE
 {
     informOnceAboutUsageTermsIfNecessary(parameters);
 
-    return new QGeoTiledMappingManagerEngineNokia(parameters, error, errorString);
+    QGeoIntrinsicNetworkAccessManager* networkManager = new QGeoIntrinsicNetworkAccessManager();
+    networkManager->setCustomProxyToken(QStringLiteral("mapping.proxy"));
+    networkManager->configure(parameters);
+
+    return new QGeoTiledMappingManagerEngineNokia(networkManager, parameters, error, errorString);
 }
 
 QGeoRoutingManagerEngine* QGeoServiceProviderFactoryNokia::createRoutingManagerEngine(const QMap<QString, QVariant> &parameters,
@@ -89,7 +98,11 @@ QGeoRoutingManagerEngine* QGeoServiceProviderFactoryNokia::createRoutingManagerE
 {
     informOnceAboutUsageTermsIfNecessary(parameters);
 
-    return new QGeoRoutingManagerEngineNokia(parameters, error, errorString);
+    QGeoIntrinsicNetworkAccessManager* networkManager = new QGeoIntrinsicNetworkAccessManager();
+    networkManager->setCustomProxyToken(QStringLiteral("routing.proxy"));
+    networkManager->configure(parameters);
+
+    return new QGeoRoutingManagerEngineNokia(networkManager, parameters, error, errorString);
 }
 
 QPlaceManagerEngine *QGeoServiceProviderFactoryNokia::createPlaceManagerEngine(const QMap<QString, QVariant> &parameters,
@@ -98,11 +111,15 @@ QPlaceManagerEngine *QGeoServiceProviderFactoryNokia::createPlaceManagerEngine(c
 {
     informOnceAboutUsageTermsIfNecessary(parameters);
 
+    QGeoIntrinsicNetworkAccessManager* networkManager = new QGeoIntrinsicNetworkAccessManager();
+    networkManager->setCustomProxyToken(QStringLiteral("places.proxy"));
+    networkManager->configure(parameters);
+
     switch (parameters.value(QLatin1String("places.api_version"), 2).toUInt()) {
     case 1:
-        return new QPlaceManagerEngineNokiaV1(parameters, error, errorString);
+        return new QPlaceManagerEngineNokiaV1(networkManager, parameters, error, errorString);
     case 2:
-        return new QPlaceManagerEngineNokiaV2(parameters, error, errorString);
+        return new QPlaceManagerEngineNokiaV2(networkManager, parameters, error, errorString);
     }
 
     return 0;
diff --git a/src/plugins/geoservices/nokia/qgeotiledmappingmanagerengine_nokia.cpp b/src/plugins/geoservices/nokia/qgeotiledmappingmanagerengine_nokia.cpp
index 9593ea29..76305e57 100644
--- a/src/plugins/geoservices/nokia/qgeotiledmappingmanagerengine_nokia.cpp
+++ b/src/plugins/geoservices/nokia/qgeotiledmappingmanagerengine_nokia.cpp
@@ -65,10 +65,12 @@
 
 QT_BEGIN_NAMESPACE
 
-QGeoTiledMappingManagerEngineNokia::QGeoTiledMappingManagerEngineNokia(const QMap<QString, QVariant> &parameters,
-                                                                       QGeoServiceProvider::Error *error,
-                                                                       QString *errorString)
-        : QGeoTiledMappingManagerEngine()
+QGeoTiledMappingManagerEngineNokia::QGeoTiledMappingManagerEngineNokia(
+    QGeoNetworkAccessManager* networkManager,
+    const QMap<QString, QVariant> &parameters,
+    QGeoServiceProvider::Error *error,
+    QString *errorString)
+    : QGeoTiledMappingManagerEngine()
 {
     Q_UNUSED(error);
     Q_UNUSED(errorString);
@@ -96,7 +98,7 @@ QGeoTiledMappingManagerEngineNokia::QGeoTiledMappingManagerEngineNokia(const QMa
     types << QGeoMapType(QGeoMapType::GrayStreetMap,tr("Mobile Gray Street Map"),tr("Nokia Mobile Gray Street Map"), true, 11);
     setSupportedMapTypes(types);
 
-    QGeoTileFetcherNokia *fetcher = new QGeoTileFetcherNokia(this);
+    QGeoTileFetcherNokia *fetcher = new QGeoTileFetcherNokia(networkManager, this);
     fetcher->setParams(parameters);
     fetcher->setTileSize(tileSize());
     setTileFetcher(fetcher);
diff --git a/src/plugins/geoservices/nokia/qgeotiledmappingmanagerengine_nokia.h b/src/plugins/geoservices/nokia/qgeotiledmappingmanagerengine_nokia.h
index 19efd99e..91171e03 100644
--- a/src/plugins/geoservices/nokia/qgeotiledmappingmanagerengine_nokia.h
+++ b/src/plugins/geoservices/nokia/qgeotiledmappingmanagerengine_nokia.h
@@ -63,13 +63,15 @@ QT_BEGIN_NAMESPACE
 
 class QByteArray;
 class QGeoTileSpec;
+class QGeoNetworkAccessManager;
 
 class QGeoTiledMappingManagerEngineNokia : public QGeoTiledMappingManagerEngine
 {
     Q_OBJECT
 
 public:
-    QGeoTiledMappingManagerEngineNokia(const QMap<QString, QVariant> &parameters,
+    QGeoTiledMappingManagerEngineNokia(QGeoNetworkAccessManager* networkManager,
+                                       const QMap<QString, QVariant> &parameters,
                                        QGeoServiceProvider::Error *error,
                                        QString *errorString);
     ~QGeoTiledMappingManagerEngineNokia();
diff --git a/src/plugins/geoservices/nokia/qgeotilefetcher_nokia.cpp b/src/plugins/geoservices/nokia/qgeotilefetcher_nokia.cpp
index 5df43dce..09e72343 100644
--- a/src/plugins/geoservices/nokia/qgeotilefetcher_nokia.cpp
+++ b/src/plugins/geoservices/nokia/qgeotilefetcher_nokia.cpp
@@ -50,12 +50,11 @@
 #include "qgeomapreply_nokia.h"
 #include "qgeotiledmapdata_nokia.h"
 #include "qgeotiledmappingmanagerengine_nokia.h"
+#include "qgeonetworkaccessmanager.h"
 
 #include <qgeotilespec.h>
 
-#include <QNetworkAccessManager>
-#include <QNetworkProxy>
-#include <QNetworkProxyFactory>
+#include <QDebug>
 #include <QSize>
 #include <QDir>
 #include <QUrl>
@@ -70,13 +69,18 @@ QT_BEGIN_NAMESPACE
 const char* MAPTILES_HOST = "1-4.maptile.lbs.ovi.com";
 const char* MAPTILES_HOST_CN = "a-k.maptile.maps.svc.nokia.com.cn";
 
-QGeoTileFetcherNokia::QGeoTileFetcherNokia(QGeoTiledMappingManagerEngine *engine)
+QGeoTileFetcherNokia::QGeoTileFetcherNokia(QGeoNetworkAccessManager* networkManager,
+                                           QGeoTiledMappingManagerEngine *engine)
         : QGeoTileFetcher(engine),
           m_engineNokia(static_cast<QGeoTiledMappingManagerEngineNokia*>(engine)),
-          m_networkManager(0),
+          m_networkManager(networkManager),
           m_firstSubdomain(QChar::Null),
           m_copyrightsReply(0),
-          m_maxSubdomains(0) {}
+          m_maxSubdomains(0)
+{
+    Q_ASSERT(networkManager);
+    m_networkManager->setParent(this);
+}
 
 QGeoTileFetcherNokia::~QGeoTileFetcherNokia() {}
 
@@ -86,28 +90,6 @@ bool QGeoTileFetcherNokia::init()
 
     qsrand((uint)QTime::currentTime().msec());
 
-    m_networkManager = new QNetworkAccessManager(this);
-
-    if (m_parameters.contains("proxy") || m_parameters.contains("mapping.proxy")) {
-        QString proxy = m_parameters.value("proxy").toString();
-        if (proxy.isEmpty())
-            proxy = m_parameters.value("mapping.proxy").toString();
-
-        if (!proxy.isEmpty() && proxy.toLower() != QLatin1String("system")) {
-            QUrl proxyUrl(proxy);
-            if (proxyUrl.isValid()) {
-                m_networkManager->setProxy(QNetworkProxy(QNetworkProxy::HttpProxy,
-                    proxyUrl.host(),
-                    proxyUrl.port(8080),
-                    proxyUrl.userName(),
-                    proxyUrl.password()));
-            }
-        } else if (!proxy.isEmpty()) {
-            if (QNetworkProxy::applicationProxy().type() == QNetworkProxy::NoProxy)
-                QNetworkProxyFactory::setUseSystemConfiguration(true);
-        }
-    }
-
     if (m_parameters.contains("mapping.host")) {
         QString host = m_parameters.value("mapping.host").toString();
         if (!host.isEmpty())
diff --git a/src/plugins/geoservices/nokia/qgeotilefetcher_nokia.h b/src/plugins/geoservices/nokia/qgeotilefetcher_nokia.h
index 34ba4176..3280e870 100644
--- a/src/plugins/geoservices/nokia/qgeotilefetcher_nokia.h
+++ b/src/plugins/geoservices/nokia/qgeotilefetcher_nokia.h
@@ -62,20 +62,19 @@
 
 QT_BEGIN_NAMESPACE
 
-class QNetworkAccessManager;
-
 class QGeoTiledMapReply;
 class QGeoTileSpec;
 class QGeoTiledMappingManagerEngine;
 class QGeoTiledMappingManagerEngineNokia;
 class QNetworkReply;
+class QGeoNetworkAccessManager;
 
 class QGeoTileFetcherNokia : public QGeoTileFetcher
 {
     Q_OBJECT
 
 public:
-    QGeoTileFetcherNokia(QGeoTiledMappingManagerEngine *engine);
+    QGeoTileFetcherNokia(QGeoNetworkAccessManager* networkManager, QGeoTiledMappingManagerEngine *engine);
     ~QGeoTileFetcherNokia();
 
     bool init();
@@ -111,7 +110,7 @@ private:
     void setHost(const QString& host);
 
     QGeoTiledMappingManagerEngineNokia *m_engineNokia;
-    QNetworkAccessManager *m_networkManager;
+    QGeoNetworkAccessManager *m_networkManager;
     QMap<QString, QVariant> m_parameters;
     QSize m_tileSize;
     QString m_host;
diff --git a/src/plugins/geoservices/nokia/qplacemanagerengine_nokiav1.cpp b/src/plugins/geoservices/nokia/qplacemanagerengine_nokiav1.cpp
index fe1683f6..97a1340e 100644
--- a/src/plugins/geoservices/nokia/qplacemanagerengine_nokiav1.cpp
+++ b/src/plugins/geoservices/nokia/qplacemanagerengine_nokiav1.cpp
@@ -63,32 +63,17 @@
 
 QT_USE_NAMESPACE
 
-QPlaceManagerEngineNokiaV1::QPlaceManagerEngineNokiaV1(const QMap<QString, QVariant> &parameters,
-                                                 QGeoServiceProvider::Error *error,
-                                                 QString *errorString)
+QPlaceManagerEngineNokiaV1::QPlaceManagerEngineNokiaV1(
+    QGeoNetworkAccessManager* networkManager,
+    const QMap<QString, QVariant> &parameters,
+    QGeoServiceProvider::Error *error,
+    QString *errorString)
 :   QPlaceManagerEngine(parameters)
 {
     qRegisterMetaType<QPlaceReply::Error>();
 
-    if (parameters.contains(QLatin1String("proxy")) || parameters.contains(QLatin1String("places.proxy"))) {
-        QString proxy = parameters.value("proxy").toString();
-        if (proxy.isEmpty())
-            proxy = parameters.value("places.proxy").toString();
-
-        if (!proxy.isEmpty() && proxy.toLower() != QLatin1String("system")) {
-            QUrl proxyUrl(proxy);
-            if (proxyUrl.isValid()) {
-                QPlaceRestManager::instance()->setProxy(QNetworkProxy(QNetworkProxy::HttpProxy,
-                                                                      proxyUrl.host(),
-                                                                      proxyUrl.port(8080),
-                                                                      proxyUrl.userName(),
-                                                                      proxyUrl.password()));
-            }
-        } else if (!proxy.isEmpty()) {
-            if (QNetworkProxy::applicationProxy().type() == QNetworkProxy::NoProxy)
-                QNetworkProxyFactory::setUseSystemConfiguration(true);
-        }
-    }
+    Q_ASSERT(networkManager);
+    QPlaceRestManager::instance()->setNetworkAccessManager(networkManager);
 
     if (error)
         *error = QGeoServiceProvider::NoError;
diff --git a/src/plugins/geoservices/nokia/qplacemanagerengine_nokiav1.h b/src/plugins/geoservices/nokia/qplacemanagerengine_nokiav1.h
index 436c3e6c..bc0c8642 100644
--- a/src/plugins/geoservices/nokia/qplacemanagerengine_nokiav1.h
+++ b/src/plugins/geoservices/nokia/qplacemanagerengine_nokiav1.h
@@ -55,16 +55,19 @@
 
 QT_BEGIN_NAMESPACE
 
+class QNetworkInterface;
 class QPlaceContentReply;
+class QGeoNetworkAccessManager;
 
 class QPlaceManagerEngineNokiaV1 : public QPlaceManagerEngine
 {
     Q_OBJECT
 public:
 
-    QPlaceManagerEngineNokiaV1(const QMap<QString, QVariant> &parameters,
-                             QGeoServiceProvider::Error *error,
-                             QString *errorString);
+    QPlaceManagerEngineNokiaV1(QGeoNetworkAccessManager* networkManager,
+                               const QMap<QString, QVariant> &parameters,
+                               QGeoServiceProvider::Error *error,
+                               QString *errorString);
     ~QPlaceManagerEngineNokiaV1();
 
     QPlaceDetailsReply *getPlaceDetails(const QString &placeId);
diff --git a/src/plugins/geoservices/nokia/qplacemanagerengine_nokiav2.cpp b/src/plugins/geoservices/nokia/qplacemanagerengine_nokiav2.cpp
index 5ed54525..f6869755 100644
--- a/src/plugins/geoservices/nokia/qplacemanagerengine_nokiav2.cpp
+++ b/src/plugins/geoservices/nokia/qplacemanagerengine_nokiav2.cpp
@@ -55,6 +55,7 @@
 #include "placesv2/qplacerecommendationreplyimpl.h"
 #include "placesv2/qplacedetailsreplyimpl.h"
 #include "placesv2/qplaceidreplyimpl.h"
+#include "qgeonetworkaccessmanager.h"
 
 #include <QtCore/QJsonDocument>
 #include <QtCore/QJsonObject>
@@ -88,32 +89,17 @@ static const int FIXED_CATEGORIES_indices[] = {
 static const char * const placesServerInternational = "http://api.places.lbs.maps.nokia.com/places";
 static const char * const placesServerChina = "http://api.places.lbs.maps.nokia.com.cn/places";
 
-QPlaceManagerEngineNokiaV2::QPlaceManagerEngineNokiaV2(const QMap<QString, QVariant> &parameters,
-                                                 QGeoServiceProvider::Error *error,
-                                                 QString *errorString)
-:   QPlaceManagerEngine(parameters), m_manager(new QNetworkAccessManager(this))
+QPlaceManagerEngineNokiaV2::QPlaceManagerEngineNokiaV2(
+    QGeoNetworkAccessManager* networkManager,
+    const QMap<QString, QVariant> &parameters,
+    QGeoServiceProvider::Error *error,
+    QString *errorString)
+:   QPlaceManagerEngine(parameters), m_manager(networkManager)
 {
-    m_locales.append(QLocale());
+    Q_ASSERT(networkManager);
+    m_manager->setParent(this);
 
-    if (parameters.contains(QLatin1String("proxy")) || parameters.contains(QLatin1String("places.proxy"))) {
-        QString proxy = parameters.value("proxy").toString();
-        if (proxy.isEmpty())
-            proxy = parameters.value("places.proxy").toString();
-
-        if (!proxy.isEmpty() && proxy.toLower() != QLatin1String("system")) {
-            QUrl proxyUrl(proxy);
-            if (proxyUrl.isValid()) {
-                m_manager->setProxy(QNetworkProxy(QNetworkProxy::HttpProxy,
-                                                  proxyUrl.host(),
-                                                  proxyUrl.port(8080),
-                                                  proxyUrl.userName(),
-                                                  proxyUrl.password()));
-            }
-        } else if (!proxy.isEmpty()) {
-            if (QNetworkProxy::applicationProxy().type() == QNetworkProxy::NoProxy)
-                QNetworkProxyFactory::setUseSystemConfiguration(true);
-        }
-    }
+    m_locales.append(QLocale());
 
     // Unless specified in the plugin parameters set the international places server to the builtin
     // one.  This is the server used when not in China.
@@ -139,9 +125,7 @@ QPlaceManagerEngineNokiaV2::QPlaceManagerEngineNokiaV2(const QMap<QString, QVari
         errorString->clear();
 }
 
-QPlaceManagerEngineNokiaV2::~QPlaceManagerEngineNokiaV2()
-{
-}
+QPlaceManagerEngineNokiaV2::~QPlaceManagerEngineNokiaV2() {}
 
 QPlaceDetailsReply *QPlaceManagerEngineNokiaV2::getPlaceDetails(const QString &placeId)
 {
diff --git a/src/plugins/geoservices/nokia/qplacemanagerengine_nokiav2.h b/src/plugins/geoservices/nokia/qplacemanagerengine_nokiav2.h
index 526f5bbe..746a61b6 100644
--- a/src/plugins/geoservices/nokia/qplacemanagerengine_nokiav2.h
+++ b/src/plugins/geoservices/nokia/qplacemanagerengine_nokiav2.h
@@ -61,6 +61,7 @@ class QNetworkReply;
 class QNetworkAccessManager;
 class QPlaceCategoriesReplyImpl;
 class QNetworkInfo;
+class QGeoNetworkAccessManager;
 
 struct PlaceCategoryNode
 {
@@ -76,9 +77,10 @@ class QPlaceManagerEngineNokiaV2 : public QPlaceManagerEngine
     Q_OBJECT
 
 public:
-    QPlaceManagerEngineNokiaV2(const QMap<QString, QVariant> &parameters,
-                             QGeoServiceProvider::Error *error,
-                             QString *errorString);
+    QPlaceManagerEngineNokiaV2(QGeoNetworkAccessManager* networkManager,
+                               const QMap<QString, QVariant> &parameters,
+                               QGeoServiceProvider::Error *error,
+                               QString *errorString);
     ~QPlaceManagerEngineNokiaV2();
 
     QPlaceDetailsReply *getPlaceDetails(const QString &placeId);
@@ -119,7 +121,7 @@ private slots:
 #endif
 
 private:
-    QNetworkAccessManager *m_manager;
+    QGeoNetworkAccessManager *m_manager;
 #ifdef USE_CHINA_NETWORK_REGISTRATION
     QNetworkInfo *m_networkInfo;
 #endif