Fix missing guarded pointers for mapping engine

Since mapping engine is going to be destroyed
on geoseriveprovider change/plugin unload use
QPointer to track engine existence before
making calls.

This commit refactors a bit QGeoTileRequestManager
to handle all the calls to the enigne. Check for
null pointer before calling the engine. Move
registerMap method to base class.
Update QGeoTiledMapNokia class accordingly.

Change-Id: I886e85e660b2c515e4a617e98e9cc0c3c13781b6
Reviewed-by: Alex Blasche <alexander.blasche@theqtcompany.com>

13 files changed, 128 insertions, 125 deletions

diff --git a/src/location/maps/qgeomap.cpp b/src/location/maps/qgeomap.cpp
index e633e46f..f6f8d5e2 100644
--- a/src/location/maps/qgeomap.cpp
+++ b/src/location/maps/qgeomap.cpp
@@ -127,18 +127,12 @@ QString QGeoMap::pluginString()
 QGeoCameraCapabilities QGeoMap::cameraCapabilities()
 {
     Q_D(const QGeoMap);
-    if (d->m_engine)
+    if (!d->m_engine.isNull())
         return d->m_engine->cameraCapabilities();
     else
         return QGeoCameraCapabilities();
 }
 
-QGeoMappingManagerEngine *QGeoMap::engine()
-{
-    Q_D(const QGeoMap);
-    return d->m_engine;
-}
-
 int QGeoMap::mapVersion()
 {
     return -1;
@@ -158,7 +152,9 @@ QGeoMapPrivate::QGeoMapPrivate(QGeoMappingManagerEngine *engine)
       m_controller(0),
       m_activeMapType(QGeoMapType())
 {
-    m_pluginString = m_engine->managerName() + QLatin1Char('_') + QString::number(m_engine->managerVersion());
+    if (!m_engine.isNull()) {
+        m_pluginString = m_engine->managerName() + QLatin1Char('_') + QString::number(m_engine->managerVersion());
+    }
 }
 
 QGeoMapPrivate::~QGeoMapPrivate()
@@ -174,7 +170,7 @@ void QGeoMapPrivate::setCameraData(const QGeoCameraData &cameraData)
     QGeoCameraData oldCameraData = m_cameraData;
     m_cameraData = cameraData;
 
-    if (m_engine) {
+    if (!m_engine.isNull()) {
         QGeoCameraCapabilities capabilities = m_engine->cameraCapabilities();
         if (m_cameraData.zoomLevel() < capabilities.minimumZoomLevel())
             m_cameraData.setZoomLevel(capabilities.minimumZoomLevel());
diff --git a/src/location/maps/qgeomap_p.h b/src/location/maps/qgeomap_p.h
index f2996a20..9e4d5a0d 100644
--- a/src/location/maps/qgeomap_p.h
+++ b/src/location/maps/qgeomap_p.h
@@ -88,7 +88,6 @@ public:
 
     QString pluginString();
     QGeoCameraCapabilities cameraCapabilities();
-    QGeoMappingManagerEngine *engine();
 
 protected:
     QGeoMap(QGeoMapPrivate &dd, QObject *parent = 0);
diff --git a/src/location/maps/qgeomap_p_p.h b/src/location/maps/qgeomap_p_p.h
index c106adf8..e7a23060 100644
--- a/src/location/maps/qgeomap_p_p.h
+++ b/src/location/maps/qgeomap_p_p.h
@@ -77,7 +77,7 @@ protected:
     int m_width;
     int m_height;
     double m_aspectRatio;
-    QGeoMappingManagerEngine *m_engine;
+    QPointer<QGeoMappingManagerEngine> m_engine;
     QString m_pluginString;
     QGeoMapController *m_controller;
     QGeoCameraData m_cameraData;
diff --git a/src/location/maps/qgeomappingmanagerengine_p.h b/src/location/maps/qgeomappingmanagerengine_p.h
index 7e866d89..b9565d87 100644
--- a/src/location/maps/qgeomappingmanagerengine_p.h
+++ b/src/location/maps/qgeomappingmanagerengine_p.h
@@ -81,6 +81,8 @@ public:
     virtual ~QGeoMappingManagerEngine();
 
     virtual QGeoMap *createMap() = 0;
+    virtual void registerMap(QGeoMap *map) = 0;
+    virtual void deregisterMap(QGeoMap *map) = 0;
 
     QVariantMap parameters() const;
 
diff --git a/src/location/maps/qgeotiledmap.cpp b/src/location/maps/qgeotiledmap.cpp
index 2b35cbe1..60e27d8e 100644
--- a/src/location/maps/qgeotiledmap.cpp
+++ b/src/location/maps/qgeotiledmap.cpp
@@ -54,15 +54,13 @@ QGeoTiledMap::QGeoTiledMap(QGeoTiledMappingManagerEngine *engine, QObject *paren
 {
     Q_D(QGeoTiledMap);
 
-    d->m_tileRequests = new QGeoTileRequestManager(this);
+    d->m_tileRequests = new QGeoTileRequestManager(this, engine);
 
     QObject::connect(d->m_mapScene,
                      SIGNAL(newTilesVisible(QSet<QGeoTileSpec>)),
                      this,
                      SLOT(evaluateCopyrights(QSet<QGeoTileSpec>)));
-
-    engine->registerMap(this);
-    connect(engine,
+    QObject::connect(engine,
             SIGNAL(mapVersionChanged()),
             this,
             SLOT(updateMapVersion()));
@@ -72,22 +70,20 @@ QGeoTiledMap::QGeoTiledMap(QGeoTiledMappingManagerEngine *engine, QObject *paren
 QGeoTiledMap::~QGeoTiledMap()
 {
     Q_D(QGeoTiledMap);
-    if (d->m_engine) // check if engine hasn't already been deleted
-        d->m_engine.data()->deregisterMap(this);
     delete d->m_tileRequests;
     d->m_tileRequests = 0;
 }
 
-QGeoTileRequestManager *QGeoTiledMap::getRequestManager()
+QGeoTileRequestManager *QGeoTiledMap::requestManager()
 {
     Q_D(QGeoTiledMap);
     return d->m_tileRequests;
 }
 
-void QGeoTiledMap::newTileFetched(const QGeoTileSpec &spec)
+void QGeoTiledMap::updateTile(const QGeoTileSpec &spec)
 {
     Q_D(QGeoTiledMap);
-    d->newTileFetched(spec);
+    d->updateTile(spec);
 }
 
 QGeoTileCache *QGeoTiledMap::tileCache()
@@ -152,7 +148,6 @@ QDoubleVector2D QGeoTiledMap::coordinateToItemPosition(const QGeoCoordinate &coo
 QGeoTiledMapPrivate::QGeoTiledMapPrivate(QGeoTiledMappingManagerEngine *engine)
     : QGeoMapPrivate(engine),
       m_cache(engine->tileCache()),
-      m_engine(engine),
       m_cameraTiles(new QGeoCameraTiles()),
       m_mapScene(new QGeoMapScene()),
       m_tileRequests(0)
@@ -262,13 +257,13 @@ void QGeoTiledMapPrivate::mapResized(int width, int height)
     q->evaluateCopyrights(m_cameraTiles->visibleTiles());
 }
 
-void QGeoTiledMapPrivate::newTileFetched(const QGeoTileSpec &spec)
+void QGeoTiledMapPrivate::updateTile(const QGeoTileSpec &spec)
 {
      Q_Q(QGeoTiledMap);
     // Only promote the texture up to GPU if it is visible
     if (m_cameraTiles->visibleTiles().contains(spec)){
-        QSharedPointer<QGeoTileTexture> tex = m_engine.data()->getTileTexture(spec);
-        if (tex) {
+        QSharedPointer<QGeoTileTexture> tex = m_tileRequests->tileTexture(spec);
+        if (!tex.isNull()) {
             m_mapScene->addTile(spec, tex);
             q->update();
         }
diff --git a/src/location/maps/qgeotiledmap_p.h b/src/location/maps/qgeotiledmap_p.h
index b8eac970..2dbf1754 100644
--- a/src/location/maps/qgeotiledmap_p.h
+++ b/src/location/maps/qgeotiledmap_p.h
@@ -80,15 +80,13 @@ public:
     virtual ~QGeoTiledMap();
 
     QGeoTileCache *tileCache();
-    void newTileFetched(const QGeoTileSpec &spec);
+    QGeoTileRequestManager *requestManager();
+    void updateTile(const QGeoTileSpec &spec);
 
     QGeoCoordinate itemPositionToCoordinate(const QDoubleVector2D &pos, bool clipToViewport = true) const Q_DECL_OVERRIDE;
     QDoubleVector2D coordinateToItemPosition(const QGeoCoordinate &coordinate, bool clipToViewport = true) const Q_DECL_OVERRIDE;
     void prefetchData() Q_DECL_OVERRIDE;
 
-    // Alternative to exposing this is to make tileFetched a slot, but then requestManager would
-    // need to be a QObject
-    QGeoTileRequestManager *getRequestManager();
 
 protected:
     QSGNode *updateSceneGraph(QSGNode *, QQuickWindow *window) Q_DECL_OVERRIDE;
diff --git a/src/location/maps/qgeotiledmap_p_p.h b/src/location/maps/qgeotiledmap_p_p.h
index 4c69efe9..bd4b4c05 100644
--- a/src/location/maps/qgeotiledmap_p_p.h
+++ b/src/location/maps/qgeotiledmap_p_p.h
@@ -81,7 +81,7 @@ public:
     QGeoCoordinate itemPositionToCoordinate(const QDoubleVector2D &pos) const;
     QDoubleVector2D coordinateToItemPosition(const QGeoCoordinate &coordinate) const;
 
-    void newTileFetched(const QGeoTileSpec &spec);
+    void updateTile(const QGeoTileSpec &spec);
     void prefetchTiles();
 
 protected:
@@ -91,9 +91,6 @@ protected:
 
 private:
     QGeoTileCache *m_cache;
-    //TODO: fix base pointer
-    QPointer<QGeoTiledMappingManagerEngine> m_engine;
-
     QGeoCameraTiles *m_cameraTiles;
     QGeoMapScene *m_mapScene;
     QGeoTileRequestManager *m_tileRequests;
diff --git a/src/location/maps/qgeotiledmappingmanagerengine.cpp b/src/location/maps/qgeotiledmappingmanagerengine.cpp
index c02c0f7d..96758854 100644
--- a/src/location/maps/qgeotiledmappingmanagerengine.cpp
+++ b/src/location/maps/qgeotiledmappingmanagerengine.cpp
@@ -99,13 +99,23 @@ QGeoMap *QGeoTiledMappingManagerEngine::createMap()
     return NULL;
 }
 
-void QGeoTiledMappingManagerEngine::registerMap(QGeoTiledMap *map)
+void QGeoTiledMappingManagerEngine::registerMap(QGeoMap *m)
 {
+    QGeoTiledMap* map = qobject_cast<QGeoTiledMap*>(m);
+    if (!map) {
+        qWarning() << "QGeoTiledMappingManagerEngine can only register QGeoTiledMap";
+        return;
+    }
     d_ptr->tileMaps_.insert(map);
 }
 
-void QGeoTiledMappingManagerEngine::deregisterMap(QGeoTiledMap *map)
+void QGeoTiledMappingManagerEngine::deregisterMap(QGeoMap *m)
 {
+    QGeoTiledMap* map = qobject_cast<QGeoTiledMap*>(m);
+    if (!map) {
+        qWarning() << "QGeoTiledMappingManagerEngine can only deregister QGeoTiledMap";
+        return;
+    }
     d_ptr->tileMaps_.remove(map);
     d_ptr->mapHash_.remove(map);
 
@@ -213,7 +223,7 @@ void QGeoTiledMappingManagerEngine::engineTileFinished(const QGeoTileSpec &spec,
     map = maps.constBegin();
     mapEnd = maps.constEnd();
     for (; map != mapEnd; ++map) {
-        (*map)->getRequestManager()->tileFetched(spec);
+        (*map)->requestManager()->tileFetched(spec);
     }
 }
 
@@ -237,7 +247,7 @@ void QGeoTiledMappingManagerEngine::engineTileError(const QGeoTileSpec &spec, co
     d->tileHash_.remove(spec);
 
     for (map = maps.constBegin(); map != mapEnd; ++map) {
-        (*map)->getRequestManager()->tileError(spec, errorString);
+        (*map)->requestManager()->tileError(spec, errorString);
     }
 
     emit tileError(spec, errorString);
diff --git a/src/location/maps/qgeotiledmappingmanagerengine_p.h b/src/location/maps/qgeotiledmappingmanagerengine_p.h
index d6f80db9..6cc4caea 100644
--- a/src/location/maps/qgeotiledmappingmanagerengine_p.h
+++ b/src/location/maps/qgeotiledmappingmanagerengine_p.h
@@ -72,10 +72,9 @@ public:
 
     QGeoTileFetcher *tileFetcher();
 
-    virtual QGeoMap *createMap();
-
-    void registerMap(QGeoTiledMap *map);
-    void deregisterMap(QGeoTiledMap *map);
+    QGeoMap *createMap() Q_DECL_OVERRIDE;
+    void registerMap(QGeoMap *map) Q_DECL_OVERRIDE;
+    void deregisterMap(QGeoMap *map) Q_DECL_OVERRIDE;
 
     QSize tileSize() const;
 
diff --git a/src/location/maps/qgeotilerequestmanager.cpp b/src/location/maps/qgeotilerequestmanager.cpp
index bfe6f43a..d689d618 100644
--- a/src/location/maps/qgeotilerequestmanager.cpp
+++ b/src/location/maps/qgeotilerequestmanager.cpp
@@ -34,13 +34,11 @@
 **
 ****************************************************************************/
 #include "qgeotilerequestmanager_p.h"
-
-#include <QSharedPointer>
-#include <QDebug>
 #include "qgeotilespec_p.h"
 #include "qgeotiledmap_p.h"
 #include "qgeotiledmappingmanagerengine_p.h"
 #include "qgeotilecache_p.h"
+#include <QtCore/QPointer>
 
 QT_BEGIN_NAMESPACE
 
@@ -49,51 +47,61 @@ class RetryFuture;
 class QGeoTileRequestManagerPrivate
 {
 public:
-    explicit QGeoTileRequestManagerPrivate(QGeoTiledMap *map);
+    explicit QGeoTileRequestManagerPrivate(QGeoTiledMap *map, QGeoTiledMappingManagerEngine *engine);
     ~QGeoTileRequestManagerPrivate();
 
-    QGeoTiledMap *map_;
+    QGeoTiledMap *m_map;
+    QPointer<QGeoTiledMappingManagerEngine> m_engine;
 
     QList<QSharedPointer<QGeoTileTexture> > requestTiles(const QSet<QGeoTileSpec> &tiles);
     void tileError(const QGeoTileSpec &tile, const QString &errorString);
 
-    QHash<QGeoTileSpec, int> retries_;
-    QHash<QGeoTileSpec, QSharedPointer<RetryFuture> > futures_;
-    QSet<QGeoTileSpec> requested_;
+    QHash<QGeoTileSpec, int> m_retries;
+    QHash<QGeoTileSpec, QSharedPointer<RetryFuture> > m_futures;
+    QSet<QGeoTileSpec> m_requested;
 
     void tileFetched(const QGeoTileSpec &spec);
 };
 
-QGeoTileRequestManager::QGeoTileRequestManager(QGeoTiledMap *map)
-    : d_ptr(new QGeoTileRequestManagerPrivate(map))
+QGeoTileRequestManager::QGeoTileRequestManager(QGeoTiledMap *map, QGeoTiledMappingManagerEngine *engine)
+    : d_ptr(new QGeoTileRequestManagerPrivate(map, engine))
 {
+     if (!d_ptr->m_engine.isNull())
+         d_ptr->m_engine->registerMap(d_ptr->m_map);
 }
 
 QGeoTileRequestManager::~QGeoTileRequestManager()
 {
-    delete d_ptr;
+    if (!d_ptr->m_engine.isNull())
+         d_ptr->m_engine->deregisterMap(d_ptr->m_map);
 }
 
 QList<QSharedPointer<QGeoTileTexture> > QGeoTileRequestManager::requestTiles(const QSet<QGeoTileSpec> &tiles)
 {
-    Q_D(QGeoTileRequestManager);
-    return d->requestTiles(tiles);
+    return d_ptr->requestTiles(tiles);
 }
 
 void QGeoTileRequestManager::tileFetched(const QGeoTileSpec &spec)
 {
-    Q_D(QGeoTileRequestManager);
-    d->tileFetched(spec);
+    d_ptr->tileFetched(spec);
+}
+
+QSharedPointer<QGeoTileTexture> QGeoTileRequestManager::tileTexture(const QGeoTileSpec &spec)
+{
+    if (d_ptr->m_engine)
+        return d_ptr->m_engine->getTileTexture(spec);
+    else
+        return QSharedPointer<QGeoTileTexture>();
 }
 
 void QGeoTileRequestManager::tileError(const QGeoTileSpec &tile, const QString &errorString)
 {
-    Q_D(QGeoTileRequestManager);
-    d->tileError(tile, errorString);
+    d_ptr->tileError(tile, errorString);
 }
 
-QGeoTileRequestManagerPrivate::QGeoTileRequestManagerPrivate(QGeoTiledMap *map)
-    : map_(map)
+QGeoTileRequestManagerPrivate::QGeoTileRequestManagerPrivate(QGeoTiledMap *map,QGeoTiledMappingManagerEngine *engine)
+    : m_map(map),
+      m_engine(engine)
 {
 }
 
@@ -103,8 +111,8 @@ QGeoTileRequestManagerPrivate::~QGeoTileRequestManagerPrivate()
 
 QList<QSharedPointer<QGeoTileTexture> > QGeoTileRequestManagerPrivate::requestTiles(const QSet<QGeoTileSpec> &tiles)
 {
-    QSet<QGeoTileSpec> cancelTiles = requested_ - tiles;
-    QSet<QGeoTileSpec> requestTiles = tiles - requested_;
+    QSet<QGeoTileSpec> cancelTiles = m_requested - tiles;
+    QSet<QGeoTileSpec> requestTiles = tiles - m_requested;
     QSet<QGeoTileSpec> cached;
 //    int tileSize = tiles.size();
 //    int newTiles = requestTiles.size();
@@ -113,16 +121,13 @@ QList<QSharedPointer<QGeoTileTexture> > QGeoTileRequestManagerPrivate::requestTi
 
     QList<QSharedPointer<QGeoTileTexture> > cachedTex;
 
-    QGeoTiledMappingManagerEngine *engine = map_ ?
-                static_cast<QGeoTiledMappingManagerEngine *>(map_->engine()) : 0;
-
     // remove tiles in cache from request tiles
-    if (engine) {
+    if (!m_engine.isNull()) {
         iter i = requestTiles.constBegin();
         iter end = requestTiles.constEnd();
         for (; i != end; ++i) {
             QGeoTileSpec tile = *i;
-            QSharedPointer<QGeoTileTexture> tex = engine->getTileTexture(tile);
+            QSharedPointer<QGeoTileTexture> tex = m_engine->getTileTexture(tile);
             if (tex) {
                 cachedTex << tex;
                 cached.insert(tile);
@@ -132,23 +137,23 @@ QList<QSharedPointer<QGeoTileTexture> > QGeoTileRequestManagerPrivate::requestTi
 
     requestTiles -= cached;
 
-    requested_ -= cancelTiles;
-    requested_ += requestTiles;
+    m_requested -= cancelTiles;
+    m_requested += requestTiles;
 
 //    qDebug() << "required # tiles: " << tileSize << ", new tiles: " << newTiles << ", total server requests: " << requested_.size();
 
     if (!requestTiles.isEmpty() || !cancelTiles.isEmpty()) {
-        if (engine) {
+        if (!m_engine.isNull()) {
 //            qDebug() << "new server requests: " << requestTiles.size() << ", server cancels: " << cancelTiles.size();
-            engine->updateTileRequests(map_, requestTiles, cancelTiles);
+            m_engine->updateTileRequests(m_map, requestTiles, cancelTiles);
 
             // Remove any cancelled tiles from the error retry hash to avoid
             // re-using the numbers for a totally different request cycle.
             iter i = cancelTiles.constBegin();
             iter end = cancelTiles.constEnd();
             for (; i != end; ++i) {
-                retries_.remove(*i);
-                futures_.remove(*i);
+                m_retries.remove(*i);
+                m_futures.remove(*i);
             }
         }
     }
@@ -158,10 +163,10 @@ QList<QSharedPointer<QGeoTileTexture> > QGeoTileRequestManagerPrivate::requestTi
 
 void QGeoTileRequestManagerPrivate::tileFetched(const QGeoTileSpec &spec)
 {
-    map_->newTileFetched(spec);
-    requested_.remove(spec);
-    retries_.remove(spec);
-    futures_.remove(spec);
+    m_map->updateTile(spec);
+    m_requested.remove(spec);
+    m_retries.remove(spec);
+    m_futures.remove(spec);
 }
 
 // Represents a tile that needs to be retried after a certain period of time
@@ -169,52 +174,50 @@ class RetryFuture : public QObject
 {
     Q_OBJECT
 public:
-    RetryFuture(const QGeoTileSpec &tile, QGeoTiledMap *map, QObject *parent = 0);
+    RetryFuture(const QGeoTileSpec &tile, QGeoTiledMap *map, QGeoTiledMappingManagerEngine* engine, QObject *parent = 0);
 
 public Q_SLOTS:
     void retry();
 
 private:
-    QGeoTileSpec tile_;
-    QGeoTiledMap *map_;
+    QGeoTileSpec m_tile;
+    QGeoTiledMap *m_map;
+    QPointer<QGeoTiledMappingManagerEngine> m_engine;
 };
 
-RetryFuture::RetryFuture(const QGeoTileSpec &tile, QGeoTiledMap *map, QObject *parent)
-    : QObject(parent), tile_(tile), map_(map)
+RetryFuture::RetryFuture(const QGeoTileSpec &tile, QGeoTiledMap *map, QGeoTiledMappingManagerEngine* engine, QObject *parent)
+    : QObject(parent), m_tile(tile), m_map(map), m_engine(engine)
 {}
 
 void RetryFuture::retry()
 {
     QSet<QGeoTileSpec> requestTiles;
     QSet<QGeoTileSpec> cancelTiles;
-    requestTiles.insert(tile_);
-    if (map_) {
-        QGeoTiledMappingManagerEngine *engine =
-                static_cast<QGeoTiledMappingManagerEngine *>(map_->engine());
-        engine->updateTileRequests(map_, requestTiles, cancelTiles);
-    }
+    requestTiles.insert(m_tile);
+    if (!m_engine.isNull())
+        m_engine->updateTileRequests(m_map, requestTiles, cancelTiles);
 }
 
 void QGeoTileRequestManagerPrivate::tileError(const QGeoTileSpec &tile, const QString &errorString)
 {
-    if (requested_.contains(tile)) {
-        int count = retries_.value(tile, 0);
-        retries_.insert(tile, count + 1);
+    if (m_requested.contains(tile)) {
+        int count = m_retries.value(tile, 0);
+        m_retries.insert(tile, count + 1);
 
         if (count >= 5) {
             qWarning("QGeoTileRequestManager: Failed to fetch tile (%d,%d,%d) 5 times, giving up. "
                      "Last error message was: '%s'",
                      tile.x(), tile.y(), tile.zoom(), qPrintable(errorString));
-            requested_.remove(tile);
-            retries_.remove(tile);
-            futures_.remove(tile);
+            m_requested.remove(tile);
+            m_retries.remove(tile);
+            m_futures.remove(tile);
 
         } else {
             // Exponential time backoff when retrying
             int delay = (1 << count) * 500;
 
-            QSharedPointer<RetryFuture> future(new RetryFuture(tile, map_));
-            futures_.insert(tile, future);
+            QSharedPointer<RetryFuture> future(new RetryFuture(tile,m_map,m_engine));
+            m_futures.insert(tile, future);
 
             QTimer::singleShot(delay, future.data(), SLOT(retry()));
             // Passing .data() to singleShot is ok -- Qt will clean up the
diff --git a/src/location/maps/qgeotilerequestmanager_p.h b/src/location/maps/qgeotilerequestmanager_p.h
index fa0d4edd..8ae7360a 100644
--- a/src/location/maps/qgeotilerequestmanager_p.h
+++ b/src/location/maps/qgeotilerequestmanager_p.h
@@ -47,10 +47,7 @@
 // We mean it.
 //
 
-#include <QSet>
-#include <QList>
-#include <QSharedPointer>
-#include <QString>
+#include <QtCore/QSharedPointer>
 
 QT_BEGIN_NAMESPACE
 
@@ -65,16 +62,17 @@ class QGeoTileRequestManagerPrivate;
 class QGeoTileRequestManager
 {
 public:
-    explicit QGeoTileRequestManager(QGeoTiledMap *map);
+    explicit QGeoTileRequestManager(QGeoTiledMap *map, QGeoTiledMappingManagerEngine *engine);
     ~QGeoTileRequestManager();
 
     QList<QSharedPointer<QGeoTileTexture> > requestTiles(const QSet<QGeoTileSpec> &tiles);
 
     void tileError(const QGeoTileSpec &tile, const QString &errorString);
     void tileFetched(const QGeoTileSpec &spec);
+    QSharedPointer<QGeoTileTexture> tileTexture(const QGeoTileSpec &spec);
+
 private:
-    QGeoTileRequestManagerPrivate *d_ptr;
-    Q_DECLARE_PRIVATE(QGeoTileRequestManager)
+    QScopedPointer<QGeoTileRequestManagerPrivate> d_ptr;
     Q_DISABLE_COPY(QGeoTileRequestManager)
 };
 
diff --git a/src/plugins/geoservices/nokia/qgeotiledmap_nokia.cpp b/src/plugins/geoservices/nokia/qgeotiledmap_nokia.cpp
index fa8a7831..bf58ad34 100644
--- a/src/plugins/geoservices/nokia/qgeotiledmap_nokia.cpp
+++ b/src/plugins/geoservices/nokia/qgeotiledmap_nokia.cpp
@@ -56,7 +56,8 @@ QT_BEGIN_NAMESPACE
  */
 QGeoTiledMapNokia::QGeoTiledMapNokia(QGeoTiledMappingManagerEngineNokia *engine, QObject *parent /*= 0*/) :
     QGeoTiledMap(engine, parent),
-    logo(":/images/logo.png") // HERE logo image
+    m_logo(":/images/logo.png"), // HERE logo image
+    m_engine(engine)
 {}
 
 QGeoTiledMapNokia::~QGeoTiledMapNokia() {}
@@ -67,10 +68,12 @@ void QGeoTiledMapNokia::evaluateCopyrights(const QSet<QGeoTileSpec> &visibleTile
     const int blurRate = 1;
     const int fontSize = 10;
 
-    QGeoTiledMappingManagerEngineNokia *engineNokia = static_cast<QGeoTiledMappingManagerEngineNokia *>(engine());
-    const QString copyrightsString = engineNokia->evaluateCopyrightsText(activeMapType(), mapController()->zoom(), visibleTiles);
+    if (m_engine.isNull())
+        return;
 
-    if (width() > 0 && height() > 0 && ((copyrightsString.isNull() && copyrightsSlab.isNull()) || copyrightsString != lastCopyrightsString)) {
+    const QString copyrightsString = m_engine->evaluateCopyrightsText(activeMapType(), mapController()->zoom(), visibleTiles);
+
+    if (width() > 0 && height() > 0 && ((copyrightsString.isNull() && m_copyrightsSlab.isNull()) || copyrightsString != m_lastCopyrightsString)) {
         QFont font("Sans Serif");
         font.setPixelSize(fontSize);
         font.setStyleHint(QFont::SansSerif);
@@ -78,39 +81,42 @@ void QGeoTiledMapNokia::evaluateCopyrights(const QSet<QGeoTileSpec> &visibleTile
 
         QRect textBounds = QFontMetrics(font).boundingRect(0, 0, width(), height(), Qt::AlignBottom | Qt::AlignLeft | Qt::TextWordWrap, copyrightsString);
 
-        copyrightsSlab = QImage(logo.width() + textBounds.width() + spaceToLogo + blurRate * 2,
-                                qMax(logo.height(), textBounds.height() + blurRate * 2),
+        m_copyrightsSlab = QImage(m_logo.width() + textBounds.width() + spaceToLogo + blurRate * 2,
+                                qMax(m_logo.height(), textBounds.height() + blurRate * 2),
                                 QImage::Format_ARGB32_Premultiplied);
-        copyrightsSlab.fill(Qt::transparent);
+        m_copyrightsSlab.fill(Qt::transparent);
 
-        QPainter painter(&copyrightsSlab);
-        painter.drawImage(QPoint(0, copyrightsSlab.height() - logo.height()), logo);
+        QPainter painter(&m_copyrightsSlab);
+        painter.drawImage(QPoint(0, m_copyrightsSlab.height() - m_logo.height()), m_logo);
         painter.setFont(font);
         painter.setPen(QColor(0, 0, 0, 64));
-        painter.translate(spaceToLogo + logo.width(), -blurRate);
+        painter.translate(spaceToLogo + m_logo.width(), -blurRate);
         for (int x=-blurRate; x<=blurRate; ++x) {
             for (int y=-blurRate; y<=blurRate; ++y) {
-                painter.drawText(x, y, textBounds.width(), copyrightsSlab.height(),
+                painter.drawText(x, y, textBounds.width(), m_copyrightsSlab.height(),
                                  Qt::AlignBottom | Qt::AlignLeft | Qt::TextWordWrap,
                                  copyrightsString);
             }
         }
         painter.setPen(Qt::white);
-        painter.drawText(0, 0, textBounds.width(), copyrightsSlab.height(),
+        painter.drawText(0, 0, textBounds.width(), m_copyrightsSlab.height(),
                          Qt::AlignBottom | Qt::AlignLeft | Qt::TextWordWrap,
                          copyrightsString);
         painter.end();
 
-        lastCopyrightsString = copyrightsString;
+        m_lastCopyrightsString = copyrightsString;
     }
 
-    emit copyrightsChanged(copyrightsSlab);
+    emit copyrightsChanged(m_copyrightsSlab);
 }
 
 int QGeoTiledMapNokia::mapVersion()
 {
-    QGeoTiledMappingManagerEngineNokia *engineNokia = static_cast<QGeoTiledMappingManagerEngineNokia *>(engine());
-    return engineNokia->mapVersion();
+    if (!m_engine.isNull())
+        return m_engine->mapVersion();
+    else
+        return QGeoTiledMap::mapVersion();
+
 }
 
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/nokia/qgeotiledmap_nokia.h b/src/plugins/geoservices/nokia/qgeotiledmap_nokia.h
index 776c9322..d0253343 100644
--- a/src/plugins/geoservices/nokia/qgeotiledmap_nokia.h
+++ b/src/plugins/geoservices/nokia/qgeotiledmap_nokia.h
@@ -38,8 +38,8 @@
 #define QGEOMAP_NOKIA_H
 
 #include "qgeotiledmap_p.h"
-#include <QImage>
-#include <QSize>
+#include <QtGui/QImage>
+#include <QtCore/QPointer>
 
 QT_BEGIN_NAMESPACE
 
@@ -56,13 +56,13 @@ public:
     void evaluateCopyrights(const QSet<QGeoTileSpec> &visibleTiles);
     int mapVersion();
 
-
 private:
-    Q_DISABLE_COPY(QGeoTiledMapNokia)
+    QImage m_logo;
+    QImage m_copyrightsSlab;
+    QString m_lastCopyrightsString;
+    QPointer<QGeoTiledMappingManagerEngineNokia> m_engine;
 
-    QImage logo;
-    QImage copyrightsSlab;
-    QString lastCopyrightsString;
+    Q_DISABLE_COPY(QGeoTiledMapNokia)
 };
 
 QT_END_NAMESPACE