Refactoring: removing m_reply from GeoReply classes

This patch tries to simplify the code removing the contained m_reply
from all the Geo[Map,Route,Geocode,Places]Reply classes.
The need for m_reply was associated to the "abort" method, but this
can be solved by emitting a signal in the superclass abort() method,
and connecting that to QNetworkReply::abort() in the constructor.

Since QNetworkReplyHttpImpl always sends an OperationCanceledError
it should then be safe to call deleteLater() on the network reply
in the slot connected to QNetworkReply::error

This patch also prevents the series of
"QCoreApplication::postEvent: Unexpected null receiver" warnings
that are generated due to deletingLater already deleted objects
(abort() emits an error, the reply is destroyed inside the
onError slot, but also in the abort() method).

Finally, this patch removes the setFinished() call in
QGeoRouteReply::abort() since the documentation does not mention
this, and all the subclasses do not perform this operation and
emit the corresponding signal.
tst_qgeoroutereply has been adapted accordingly.

Change-Id: I226ee163e7bed784dd7f0da1522e651459543bca
Reviewed-by: Alex Blasche <alexander.blasche@qt.io>
Reviewed-by: Edward Welbourne <edward.welbourne@qt.io>

46 files changed, 376 insertions, 686 deletions

diff --git a/src/imports/location/qdeclarativegeoroutemodel.cpp b/src/imports/location/qdeclarativegeoroutemodel.cpp
index 0c64c23a..af01d25d 100644
--- a/src/imports/location/qdeclarativegeoroutemodel.cpp
+++ b/src/imports/location/qdeclarativegeoroutemodel.cpp
@@ -120,7 +120,6 @@ QDeclarativeGeoRouteModel::QDeclarativeGeoRouteModel(QObject *parent)
       complete_(false),
       plugin_(0),
       routeQuery_(0),
-      reply_(0),
       autoUpdate_(false),
       status_(QDeclarativeGeoRouteModel::Null),
       error_(QDeclarativeGeoRouteModel::NoError)
@@ -133,7 +132,6 @@ QDeclarativeGeoRouteModel::~QDeclarativeGeoRouteModel()
         qDeleteAll(routes_);
         routes_.clear();
     }
-    delete reply_;
 }
 
 /*!
@@ -168,7 +166,7 @@ void QDeclarativeGeoRouteModel::reset()
         endResetModel();
     }
 
-    abortRequest();
+    emit abortRequested();
     setError(NoError, QString());
     setStatus(QDeclarativeGeoRouteModel::Null);
 }
@@ -181,25 +179,12 @@ void QDeclarativeGeoRouteModel::reset()
 */
 void QDeclarativeGeoRouteModel::cancel()
 {
-    abortRequest();
+    emit abortRequested();
     setError(NoError, QString());
     setStatus(routes_.isEmpty() ? Null : Ready);
 }
 
 /*!
-    \internal
-*/
-void QDeclarativeGeoRouteModel::abortRequest()
-{
-    if (reply_) {
-        reply_->abort();
-        reply_->deleteLater();
-        reply_ = 0;
-    }
-}
-
-
-/*!
     \qmlmethod void QtLocation::RouteModel::get(int)
 
     Returns the Route at given index. Use \l count property to check the
@@ -589,7 +574,7 @@ void QDeclarativeGeoRouteModel::update()
         setError(ParseError,"Cannot route, valid query not set.");
         return;
     }
-    abortRequest(); // Clear previus requests
+    emit abortRequested(); // Clear previous requests
     QGeoRouteRequest request = routeQuery_->routeRequest();
     if (request.waypoints().count() < 2) {
         setError(ParseError,tr("Not enough waypoints for routing."));
@@ -598,13 +583,15 @@ void QDeclarativeGeoRouteModel::update()
 
     setError(NoError, QString());
 
-    reply_ = routingManager->calculateRoute(request);
+    QGeoRouteReply *reply = routingManager->calculateRoute(request);
     setStatus(QDeclarativeGeoRouteModel::Loading);
-    if (reply_->isFinished()) {
-        if (reply_->error() == QGeoRouteReply::NoError) {
-            routingFinished(reply_);
+    if (!reply->isFinished()) {
+        connect(this, &QDeclarativeGeoRouteModel::abortRequested, reply, &QGeoRouteReply::abort);
+    } else {
+        if (reply->error() == QGeoRouteReply::NoError) {
+            routingFinished(reply);
         } else {
-            routingError(reply_, reply_->error(), reply_->errorString());
+            routingError(reply, reply->error(), reply->errorString());
         }
     }
 }
@@ -614,7 +601,10 @@ void QDeclarativeGeoRouteModel::update()
 */
 void QDeclarativeGeoRouteModel::routingFinished(QGeoRouteReply *reply)
 {
-    if (reply != reply_ || reply->error() != QGeoRouteReply::NoError)
+    if (!reply)
+        return;
+    reply->deleteLater();
+    if (reply->error() != QGeoRouteReply::NoError)
         return;
 
     beginResetModel();
@@ -632,9 +622,6 @@ void QDeclarativeGeoRouteModel::routingFinished(QGeoRouteReply *reply)
     setError(NoError, QString());
     setStatus(QDeclarativeGeoRouteModel::Ready);
 
-    reply->deleteLater();
-    reply_ = 0;
-
     if (oldCount != 0 || routes_.count() != 0)
         emit routesChanged();
     if (oldCount != routes_.count())
@@ -648,12 +635,11 @@ void QDeclarativeGeoRouteModel::routingError(QGeoRouteReply *reply,
                                                QGeoRouteReply::Error error,
                                                const QString &errorString)
 {
-    if (reply != reply_)
+    if (!reply)
         return;
+    reply->deleteLater();
     setError(static_cast<QDeclarativeGeoRouteModel::RouteError>(error), errorString);
     setStatus(QDeclarativeGeoRouteModel::Error);
-    reply->deleteLater();
-    reply_ = 0;
 }
 
 
diff --git a/src/imports/location/qdeclarativegeoroutemodel_p.h b/src/imports/location/qdeclarativegeoroutemodel_p.h
index 66769ea7..30fc1ecc 100644
--- a/src/imports/location/qdeclarativegeoroutemodel_p.h
+++ b/src/imports/location/qdeclarativegeoroutemodel_p.h
@@ -155,6 +155,7 @@ Q_SIGNALS:
     void errorChanged(); //emitted also for errorString notification
     void routesChanged();
     void measurementSystemChanged();
+    void abortRequested();
 
 public Q_SLOTS:
     void update();
@@ -170,13 +171,11 @@ private Q_SLOTS:
 private:
     void setStatus(Status status);
     void setError(RouteError error, const QString &errorString);
-    void abortRequest();
 
     bool complete_;
 
     QDeclarativeGeoServiceProvider *plugin_;
     QDeclarativeGeoRouteQuery *routeQuery_;
-    QGeoRouteReply *reply_;
 
     QList<QDeclarativeGeoRoute *> routes_;
     bool autoUpdate_;
diff --git a/src/location/maps/qgeocodereply.cpp b/src/location/maps/qgeocodereply.cpp
index 47018217..d5112a69 100644
--- a/src/location/maps/qgeocodereply.cpp
+++ b/src/location/maps/qgeocodereply.cpp
@@ -233,6 +233,7 @@ void QGeoCodeReply::abort()
 {
     if (!isFinished())
         setFinished(true);
+    emit aborted();
 }
 
 /*!
diff --git a/src/location/maps/qgeocodereply.h b/src/location/maps/qgeocodereply.h
index 048493b4..c92bc606 100644
--- a/src/location/maps/qgeocodereply.h
+++ b/src/location/maps/qgeocodereply.h
@@ -80,6 +80,7 @@ public:
 
 Q_SIGNALS:
     void finished();
+    void aborted();
     void error(QGeoCodeReply::Error error, const QString &errorString = QString());
 
 protected:
diff --git a/src/location/maps/qgeoroutereply.cpp b/src/location/maps/qgeoroutereply.cpp
index ab869d3c..b1c98349 100644
--- a/src/location/maps/qgeoroutereply.cpp
+++ b/src/location/maps/qgeoroutereply.cpp
@@ -218,8 +218,7 @@ void QGeoRouteReply::addRoutes(const QList<QGeoRoute> &routes)
 */
 void QGeoRouteReply::abort()
 {
-    if (!isFinished())
-        setFinished(true);
+    emit aborted();
 }
 
 /*!
diff --git a/src/location/maps/qgeoroutereply.h b/src/location/maps/qgeoroutereply.h
index 318d85f8..c1d6e8d1 100644
--- a/src/location/maps/qgeoroutereply.h
+++ b/src/location/maps/qgeoroutereply.h
@@ -74,6 +74,7 @@ public:
 
 Q_SIGNALS:
     void finished();
+    void aborted();
     void error(QGeoRouteReply::Error error, const QString &errorString = QString());
 
 protected:
diff --git a/src/location/maps/qgeotiledmapreply.cpp b/src/location/maps/qgeotiledmapreply.cpp
index f2dfd9eb..34ca041f 100644
--- a/src/location/maps/qgeotiledmapreply.cpp
+++ b/src/location/maps/qgeotiledmapreply.cpp
@@ -242,6 +242,7 @@ void QGeoTiledMapReply::abort()
 {
     if (!isFinished())
         setFinished(true);
+    emit aborted();
 }
 
 /*
diff --git a/src/location/maps/qgeotiledmapreply_p.h b/src/location/maps/qgeotiledmapreply_p.h
index 91852cc3..fc991bb7 100644
--- a/src/location/maps/qgeotiledmapreply_p.h
+++ b/src/location/maps/qgeotiledmapreply_p.h
@@ -88,6 +88,7 @@ public:
 
 Q_SIGNALS:
     void finished();
+    void aborted();
     void error(QGeoTiledMapReply::Error error, const QString &errorString = QString());
 
 protected:
diff --git a/src/location/places/qplacereply.cpp b/src/location/places/qplacereply.cpp
index 0590871d..582987b4 100644
--- a/src/location/places/qplacereply.cpp
+++ b/src/location/places/qplacereply.cpp
@@ -199,6 +199,7 @@ QPlaceReply::Error QPlaceReply::error() const
 */
 void QPlaceReply::abort()
 {
+    emit aborted();
 }
 
 /*!
diff --git a/src/location/places/qplacereply.h b/src/location/places/qplacereply.h
index 374c68b3..3eb3d6cc 100644
--- a/src/location/places/qplacereply.h
+++ b/src/location/places/qplacereply.h
@@ -86,6 +86,7 @@ public Q_SLOTS:
 
 Q_SIGNALS:
     void finished();
+    void aborted();
     void error(QPlaceReply::Error error, const QString &errorString = QString());
 
 protected:
diff --git a/src/plugins/geoservices/esri/geocodereply_esri.cpp b/src/plugins/geoservices/esri/geocodereply_esri.cpp
index a7ad9368..f1dac184 100644
--- a/src/plugins/geoservices/esri/geocodereply_esri.cpp
+++ b/src/plugins/geoservices/esri/geocodereply_esri.cpp
@@ -51,11 +51,17 @@ QT_BEGIN_NAMESPACE
 
 GeoCodeReplyEsri::GeoCodeReplyEsri(QNetworkReply *reply, OperationType operationType,
                                    QObject *parent) :
-    QGeoCodeReply(parent), m_reply(reply), m_operationType(operationType)
+    QGeoCodeReply(parent), m_operationType(operationType)
 {
-    connect(m_reply, SIGNAL(finished()), this, SLOT(networkReplyFinished()));
-    connect(m_reply, SIGNAL(error(QNetworkReply::NetworkError)),
+    if (!reply) {
+        setError(UnknownError, QStringLiteral("Null reply"));
+        return;
+    }
+    connect(reply, SIGNAL(finished()), this, SLOT(networkReplyFinished()));
+    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
             this, SLOT(networkReplyError(QNetworkReply::NetworkError)));
+    connect(this, &QGeoCodeReply::aborted, reply, &QNetworkReply::abort);
+    connect(this, &QObject::destroyed, reply, &QObject::deleteLater);
 
     setLimit(1);
     setOffset(0);
@@ -63,49 +69,25 @@ GeoCodeReplyEsri::GeoCodeReplyEsri(QNetworkReply *reply, OperationType operation
 
 GeoCodeReplyEsri::~GeoCodeReplyEsri()
 {
-    if (m_reply)
-        m_reply->deleteLater();
-}
-
-void GeoCodeReplyEsri::abort()
-{
-    if (!m_reply)
-        return;
-
-    m_reply->abort();
-    QGeoCodeReply::abort();
-
-    m_reply->deleteLater();
-    m_reply = Q_NULLPTR;
 }
 
 void GeoCodeReplyEsri::networkReplyError(QNetworkReply::NetworkError error)
 {
     Q_UNUSED(error)
-
-    if (!m_reply)
-        return;
-
-    setError(QGeoCodeReply::CommunicationError, m_reply->errorString());
-
-    m_reply->deleteLater();
-    m_reply = Q_NULLPTR;
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
+    setError(QGeoCodeReply::CommunicationError, reply->errorString());
 }
 
 void GeoCodeReplyEsri::networkReplyFinished()
 {
-    if (!m_reply)
-        return;
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
 
-    if (m_reply->error() != QNetworkReply::NoError)
-    {
-        setError(QGeoCodeReply::CommunicationError, m_reply->errorString());
-        m_reply->deleteLater();
-        m_reply = Q_NULLPTR;
+    if (reply->error() != QNetworkReply::NoError)
         return;
-    }
 
-    QJsonDocument document = QJsonDocument::fromJson(m_reply->readAll());
+    QJsonDocument document = QJsonDocument::fromJson(reply->readAll());
 
     if (document.isObject()) {
         QJsonObject object = document.object();
@@ -148,9 +130,6 @@ void GeoCodeReplyEsri::networkReplyFinished()
     } else {
         setError(QGeoCodeReply::CommunicationError, QStringLiteral("Unknown document"));
     }
-
-    m_reply->deleteLater();
-    m_reply = Q_NULLPTR;
 }
 
 QGeoLocation GeoCodeReplyEsri::parseAddress(const QJsonObject& object)
diff --git a/src/plugins/geoservices/esri/geocodereply_esri.h b/src/plugins/geoservices/esri/geocodereply_esri.h
index 4434b7dc..a857599b 100644
--- a/src/plugins/geoservices/esri/geocodereply_esri.h
+++ b/src/plugins/geoservices/esri/geocodereply_esri.h
@@ -58,9 +58,7 @@ public:
 
 public:
     GeoCodeReplyEsri(QNetworkReply *reply, OperationType operationType, QObject *parent = Q_NULLPTR);
-    virtual ~GeoCodeReplyEsri();
-
-    void abort() Q_DECL_OVERRIDE;
+    ~GeoCodeReplyEsri();
 
     inline OperationType operationType() const;
 
@@ -72,7 +70,6 @@ private Q_SLOTS:
     QGeoLocation parseCandidate(const QJsonObject &candidate);
 
 private:
-    QNetworkReply *m_reply;
     OperationType m_operationType;
 };
 
diff --git a/src/plugins/geoservices/esri/georoutereply_esri.cpp b/src/plugins/geoservices/esri/georoutereply_esri.cpp
index 4a7d5c67..811ffd0d 100644
--- a/src/plugins/geoservices/esri/georoutereply_esri.cpp
+++ b/src/plugins/geoservices/esri/georoutereply_esri.cpp
@@ -48,43 +48,32 @@ QT_BEGIN_NAMESPACE
 
 GeoRouteReplyEsri::GeoRouteReplyEsri(QNetworkReply *reply, const QGeoRouteRequest &request,
                                      QObject *parent) :
-    QGeoRouteReply(request, parent), m_reply(reply)
+    QGeoRouteReply(request, parent)
 {
-    connect(m_reply, SIGNAL(finished()), this, SLOT(networkReplyFinished()));
-    connect(m_reply, SIGNAL(error(QNetworkReply::NetworkError)),
+    if (!reply) {
+        setError(UnknownError, QStringLiteral("Null reply"));
+        return;
+    }
+    connect(reply, SIGNAL(finished()), this, SLOT(networkReplyFinished()));
+    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
             this, SLOT(networkReplyError(QNetworkReply::NetworkError)));
+    connect(this, &QGeoRouteReply::aborted, reply, &QNetworkReply::abort);
+    connect(this, &QObject::destroyed, reply, &QObject::deleteLater);
 }
 
 GeoRouteReplyEsri::~GeoRouteReplyEsri()
 {
-    if (m_reply)
-        m_reply->deleteLater();
-}
-
-void GeoRouteReplyEsri::abort()
-{
-    if (!m_reply)
-        return;
-
-    m_reply->abort();
-    m_reply->deleteLater();
-    m_reply = Q_NULLPTR;
 }
 
 void GeoRouteReplyEsri::networkReplyFinished()
 {
-    if (!m_reply)
-        return;
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
 
-    if (m_reply->error() != QNetworkReply::NoError)
-    {
-        setError(QGeoRouteReply::CommunicationError, m_reply->errorString());
-        m_reply->deleteLater();
-        m_reply = Q_NULLPTR;
+    if (reply->error() != QNetworkReply::NoError)
         return;
-    }
 
-    QJsonDocument document = QJsonDocument::fromJson(m_reply->readAll());
+    QJsonDocument document = QJsonDocument::fromJson(reply->readAll());
     GeoRouteJsonParserEsri parser(document);
 
     if (parser.isValid())
@@ -94,21 +83,14 @@ void GeoRouteReplyEsri::networkReplyFinished()
     } else {
         setError(QGeoRouteReply::ParseError, parser.errorString());
     }
-
-    m_reply->deleteLater();
-    m_reply = Q_NULLPTR;
 }
 
 void GeoRouteReplyEsri::networkReplyError(QNetworkReply::NetworkError error)
 {
     Q_UNUSED(error)
-
-    if (!m_reply)
-        return;
-
-    setError(QGeoRouteReply::CommunicationError, m_reply->errorString());
-    m_reply->deleteLater();
-    m_reply = Q_NULLPTR;
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
+    setError(QGeoRouteReply::CommunicationError, reply->errorString());
 }
 
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/esri/georoutereply_esri.h b/src/plugins/geoservices/esri/georoutereply_esri.h
index 6e97ee9f..049dc3ba 100644
--- a/src/plugins/geoservices/esri/georoutereply_esri.h
+++ b/src/plugins/geoservices/esri/georoutereply_esri.h
@@ -51,16 +51,11 @@ class GeoRouteReplyEsri : public QGeoRouteReply
 
 public:
     GeoRouteReplyEsri(QNetworkReply *reply, const QGeoRouteRequest &request, QObject *parent = Q_NULLPTR);
-    virtual ~GeoRouteReplyEsri();
-
-    void abort() Q_DECL_OVERRIDE;
+    ~GeoRouteReplyEsri();
 
 private Q_SLOTS:
     void networkReplyFinished();
     void networkReplyError(QNetworkReply::NetworkError error);
-
-private:
-    QNetworkReply *m_reply;
 };
 
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/esri/geotiledmapreply_esri.cpp b/src/plugins/geoservices/esri/geotiledmapreply_esri.cpp
index e0816c15..f4431bf0 100644
--- a/src/plugins/geoservices/esri/geotiledmapreply_esri.cpp
+++ b/src/plugins/geoservices/esri/geotiledmapreply_esri.cpp
@@ -49,50 +49,32 @@ static const unsigned char gifSignature[] = {0x47, 0x49, 0x46, 0x38, 0x00};
 
 GeoTiledMapReplyEsri::GeoTiledMapReplyEsri(QNetworkReply *reply, const QGeoTileSpec &spec,
                                            QObject *parent) :
-    QGeoTiledMapReply(spec, parent), m_reply(reply)
+    QGeoTiledMapReply(spec, parent)
 {
-    connect(m_reply, SIGNAL(finished()), this, SLOT(networkReplyFinished()));
-    connect(m_reply, SIGNAL(error(QNetworkReply::NetworkError)),
+    if (!reply) {
+        setError(UnknownError, QStringLiteral("Null reply"));
+        return;
+    }
+    connect(reply, SIGNAL(finished()), this, SLOT(networkReplyFinished()));
+    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
             this, SLOT(networkReplyError(QNetworkReply::NetworkError)));
-    connect(m_reply, SIGNAL(destroyed()), this, SLOT(replyDestroyed()));
+    connect(this, &QGeoTiledMapReply::aborted, reply, &QNetworkReply::abort);
+    connect(this, &QObject::destroyed, reply, &QObject::deleteLater);
 }
 
 GeoTiledMapReplyEsri::~GeoTiledMapReplyEsri()
 {
-    if (m_reply) {
-        m_reply->deleteLater();
-        m_reply = Q_NULLPTR;
-    }
-}
-
-void GeoTiledMapReplyEsri::abort()
-{
-    if (!m_reply)
-        return;
-
-    m_reply->abort();
-    QGeoTiledMapReply::abort();
-}
-
-void GeoTiledMapReplyEsri::replyDestroyed()
-{
-    m_reply = Q_NULLPTR;
 }
 
 void GeoTiledMapReplyEsri::networkReplyFinished()
 {
-    if (!m_reply)
-        return;
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
 
-    if (m_reply->error() != QNetworkReply::NoError)
-    {
-        setError(QGeoTiledMapReply::CommunicationError, m_reply->errorString());
-        m_reply->deleteLater();
-        m_reply = Q_NULLPTR;
+    if (reply->error() != QNetworkReply::NoError)
         return;
-    }
 
-    QByteArray const& imageData = m_reply->readAll();
+    QByteArray const& imageData = reply->readAll();
 
     bool validFormat = true;
     if (imageData.startsWith(reinterpret_cast<const char*>(pngSignature)))
@@ -108,22 +90,16 @@ void GeoTiledMapReplyEsri::networkReplyFinished()
         setMapImageData(imageData);
 
     setFinished(true);
-
-    m_reply->deleteLater();
-    m_reply = Q_NULLPTR;
 }
 
 void GeoTiledMapReplyEsri::networkReplyError(QNetworkReply::NetworkError error)
 {
-    if (!m_reply)
-        return;
-
-    if (error != QNetworkReply::OperationCanceledError)
-        setError(QGeoTiledMapReply::CommunicationError, m_reply->errorString());
-
-    setFinished(true);
-    m_reply->deleteLater();
-    m_reply = Q_NULLPTR;
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
+    if (error == QNetworkReply::OperationCanceledError)
+        setFinished(true);
+    else
+        setError(QGeoTiledMapReply::CommunicationError, reply->errorString());
 }
 
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/esri/geotiledmapreply_esri.h b/src/plugins/geoservices/esri/geotiledmapreply_esri.h
index 32a35698..b459e943 100644
--- a/src/plugins/geoservices/esri/geotiledmapreply_esri.h
+++ b/src/plugins/geoservices/esri/geotiledmapreply_esri.h
@@ -52,17 +52,11 @@ class GeoTiledMapReplyEsri : public QGeoTiledMapReply
 
 public:
     GeoTiledMapReplyEsri(QNetworkReply *reply, const QGeoTileSpec &spec, QObject *parent = Q_NULLPTR);
-    virtual ~GeoTiledMapReplyEsri();
-
-    void abort() Q_DECL_OVERRIDE;
+    ~GeoTiledMapReplyEsri();
 
 private Q_SLOTS:
-    void replyDestroyed();
     void networkReplyFinished();
     void networkReplyError(QNetworkReply::NetworkError error);
-
-private:
-    QNetworkReply *m_reply;
 };
 
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/mapbox/qgeomapreplymapbox.cpp b/src/plugins/geoservices/mapbox/qgeomapreplymapbox.cpp
index 5fe9caa8..4b60231d 100644
--- a/src/plugins/geoservices/mapbox/qgeomapreplymapbox.cpp
+++ b/src/plugins/geoservices/mapbox/qgeomapreplymapbox.cpp
@@ -39,59 +39,42 @@
 #include <QtLocation/private/qgeotilespec_p.h>
 
 QGeoMapReplyMapbox::QGeoMapReplyMapbox(QNetworkReply *reply, const QGeoTileSpec &spec, const QString &format, QObject *parent)
-:   QGeoTiledMapReply(spec, parent), m_reply(reply), m_format (format)
+:   QGeoTiledMapReply(spec, parent), m_format (format)
 {
-    connect(m_reply, SIGNAL(finished()), this, SLOT(networkReplyFinished()));
-    connect(m_reply, SIGNAL(error(QNetworkReply::NetworkError)),
+    if (!reply) {
+        setError(UnknownError, QStringLiteral("Null reply"));
+        return;
+    }
+    connect(reply, SIGNAL(finished()), this, SLOT(networkReplyFinished()));
+    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
             this, SLOT(networkReplyError(QNetworkReply::NetworkError)));
+    connect(this, &QGeoTiledMapReply::aborted, reply, &QNetworkReply::abort);
+    connect(this, &QObject::destroyed, reply, &QObject::deleteLater);
 }
 
 QGeoMapReplyMapbox::~QGeoMapReplyMapbox()
 {
-    if (m_reply) {
-        m_reply->deleteLater();
-        m_reply = 0;
-    }
-}
-
-void QGeoMapReplyMapbox::abort()
-{
-    if (!m_reply)
-        return;
-
-    m_reply->abort();
-}
-
-QNetworkReply *QGeoMapReplyMapbox::networkReply() const
-{
-    return m_reply;
 }
 
 void QGeoMapReplyMapbox::networkReplyFinished()
 {
-    if (!m_reply)
-        return;
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
 
-    if (m_reply->error() != QNetworkReply::NoError)
+    if (reply->error() != QNetworkReply::NoError)
         return;
 
-    setMapImageData(m_reply->readAll());
+    setMapImageData(reply->readAll());
     setMapImageFormat(m_format);
     setFinished(true);
-
-    m_reply->deleteLater();
-    m_reply = 0;
 }
 
 void QGeoMapReplyMapbox::networkReplyError(QNetworkReply::NetworkError error)
 {
-    if (!m_reply)
-        return;
-
-    if (error != QNetworkReply::OperationCanceledError)
-        setError(QGeoTiledMapReply::CommunicationError, m_reply->errorString());
-
-    setFinished(true);
-    m_reply->deleteLater();
-    m_reply = 0;
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
+    if (error == QNetworkReply::OperationCanceledError)
+        setFinished(true);
+    else
+        setError(QGeoTiledMapReply::CommunicationError, reply->errorString());
 }
diff --git a/src/plugins/geoservices/mapbox/qgeomapreplymapbox.h b/src/plugins/geoservices/mapbox/qgeomapreplymapbox.h
index 67ad61ad..c4a1dd82 100644
--- a/src/plugins/geoservices/mapbox/qgeomapreplymapbox.h
+++ b/src/plugins/geoservices/mapbox/qgeomapreplymapbox.h
@@ -51,16 +51,11 @@ public:
     explicit QGeoMapReplyMapbox(QNetworkReply *reply, const QGeoTileSpec &spec, const QString &format, QObject *parent = 0);
     ~QGeoMapReplyMapbox();
 
-    void abort();
-
-    QNetworkReply *networkReply() const;
-
 private Q_SLOTS:
     void networkReplyFinished();
     void networkReplyError(QNetworkReply::NetworkError error);
 
 private:
-    QPointer<QNetworkReply> m_reply;
     QString m_format;
 };
 
diff --git a/src/plugins/geoservices/mapbox/qgeoroutereplymapbox.cpp b/src/plugins/geoservices/mapbox/qgeoroutereplymapbox.cpp
index 4c98412b..8fc3386a 100644
--- a/src/plugins/geoservices/mapbox/qgeoroutereplymapbox.cpp
+++ b/src/plugins/geoservices/mapbox/qgeoroutereplymapbox.cpp
@@ -84,28 +84,21 @@ static QList<QGeoCoordinate> parseGeometry(const QJsonValue &geometry)
 
 QGeoRouteReplyMapbox::QGeoRouteReplyMapbox(QNetworkReply *reply, const QGeoRouteRequest &request,
                                      QObject *parent)
-:   QGeoRouteReply(request, parent), m_reply(reply)
+:   QGeoRouteReply(request, parent)
 {
-    connect(m_reply, SIGNAL(finished()), this, SLOT(networkReplyFinished()));
-    connect(m_reply, SIGNAL(error(QNetworkReply::NetworkError)),
+    if (!reply) {
+        setError(UnknownError, QStringLiteral("Null reply"));
+        return;
+    }
+    connect(reply, SIGNAL(finished()), this, SLOT(networkReplyFinished()));
+    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
             this, SLOT(networkReplyError(QNetworkReply::NetworkError)));
+    connect(this, &QGeoRouteReply::aborted, reply, &QNetworkReply::abort);
+    connect(this, &QObject::destroyed, reply, &QObject::deleteLater);
 }
 
 QGeoRouteReplyMapbox::~QGeoRouteReplyMapbox()
 {
-    if (m_reply)
-        m_reply->deleteLater();
-}
-
-void QGeoRouteReplyMapbox::abort()
-{
-    if (!m_reply)
-        return;
-
-    m_reply->abort();
-
-    m_reply->deleteLater();
-    m_reply = 0;
 }
 
 static QGeoRoute constructRoute(const QJsonObject &obj)
@@ -177,25 +170,19 @@ static QGeoRoute constructRoute(const QJsonObject &obj)
 
 void QGeoRouteReplyMapbox::networkReplyFinished()
 {
-    if (!m_reply)
-        return;
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
 
-    if (m_reply->error() != QNetworkReply::NoError) {
-        setError(QGeoRouteReply::CommunicationError, m_reply->errorString());
-        m_reply->deleteLater();
-        m_reply = 0;
+    if (reply->error() != QNetworkReply::NoError)
         return;
-    }
 
-    QJsonDocument document = QJsonDocument::fromJson(m_reply->readAll());
+    QJsonDocument document = QJsonDocument::fromJson(reply->readAll());
     if (document.isObject()) {
         QJsonObject object = document.object();
 
         QString status = object.value(QStringLiteral("code")).toString();
         if (status != QStringLiteral("Ok")) {
             setError(QGeoRouteReply::UnknownError, object.value(QStringLiteral("message")).toString());
-            m_reply->deleteLater();
-            m_reply = 0;
             return;
         }
 
@@ -210,22 +197,14 @@ void QGeoRouteReplyMapbox::networkReplyFinished()
     } else {
         setError(QGeoRouteReply::ParseError, QStringLiteral("Couldn't parse json."));
     }
-
-    m_reply->deleteLater();
-    m_reply = 0;
 }
 
 void QGeoRouteReplyMapbox::networkReplyError(QNetworkReply::NetworkError error)
 {
     Q_UNUSED(error)
-
-    if (!m_reply)
-        return;
-
-    setError(QGeoRouteReply::CommunicationError, m_reply->errorString());
-
-    m_reply->deleteLater();
-    m_reply = 0;
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
+    setError(QGeoRouteReply::CommunicationError, reply->errorString());
 }
 
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/mapbox/qgeoroutereplymapbox.h b/src/plugins/geoservices/mapbox/qgeoroutereplymapbox.h
index 9df45ac4..f19faee7 100644
--- a/src/plugins/geoservices/mapbox/qgeoroutereplymapbox.h
+++ b/src/plugins/geoservices/mapbox/qgeoroutereplymapbox.h
@@ -55,14 +55,9 @@ public:
     QGeoRouteReplyMapbox(QNetworkReply *reply, const QGeoRouteRequest &request, QObject *parent = 0);
     ~QGeoRouteReplyMapbox();
 
-    void abort() Q_DECL_OVERRIDE;
-
 private Q_SLOTS:
     void networkReplyFinished();
     void networkReplyError(QNetworkReply::NetworkError error);
-
-private:
-    QNetworkReply *m_reply;
 };
 
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/nokia/placesv2/qplacecontentreplyimpl.cpp b/src/plugins/geoservices/nokia/placesv2/qplacecontentreplyimpl.cpp
index 9a5cbf48..f67fa5bb 100644
--- a/src/plugins/geoservices/nokia/placesv2/qplacecontentreplyimpl.cpp
+++ b/src/plugins/geoservices/nokia/placesv2/qplacecontentreplyimpl.cpp
@@ -48,30 +48,26 @@ QT_BEGIN_NAMESPACE
 QPlaceContentReplyImpl::QPlaceContentReplyImpl(const QPlaceContentRequest &request,
                                                QNetworkReply *reply,
                                                QPlaceManagerEngineNokiaV2 *engine)
-    :   QPlaceContentReply(engine), m_reply(reply), m_engine(engine)
+    :   QPlaceContentReply(engine), m_engine(engine)
 {
     Q_ASSERT(engine);
-    setRequest(request);
-
-    if (!m_reply)
+    if (!reply) {
+        setError(UnknownError, QStringLiteral("Null reply"));
         return;
+    }
+    setRequest(request);
 
-    m_reply->setParent(this);
-    connect(m_reply, SIGNAL(finished()), this, SLOT(replyFinished()));
-    connect(m_reply, SIGNAL(error(QNetworkReply::NetworkError)),
+    connect(reply, SIGNAL(finished()), this, SLOT(replyFinished()));
+    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
             this, SLOT(replyError(QNetworkReply::NetworkError)));
+    connect(this, &QPlaceReply::aborted, reply, &QNetworkReply::abort);
+    connect(this, &QObject::destroyed, reply, &QObject::deleteLater);
 }
 
 QPlaceContentReplyImpl::~QPlaceContentReplyImpl()
 {
 }
 
-void QPlaceContentReplyImpl::abort()
-{
-    if (m_reply)
-        m_reply->abort();
-}
-
 void QPlaceContentReplyImpl::setError(QPlaceReply::Error error_, const QString &errorString)
 {
     QPlaceContentReply::setError(error_, errorString);
@@ -82,31 +78,32 @@ void QPlaceContentReplyImpl::setError(QPlaceReply::Error error_, const QString &
 
 void QPlaceContentReplyImpl::replyFinished()
 {
-    if (m_reply->isOpen()) {
-        QJsonDocument document = QJsonDocument::fromJson(m_reply->readAll());
-        if (!document.isObject()) {
-            setError(ParseError, QCoreApplication::translate(NOKIA_PLUGIN_CONTEXT_NAME, PARSE_ERROR));
-            return;
-        }
-
-        QJsonObject object = document.object();
-
-        QPlaceContent::Collection collection;
-        int totalCount;
-        QPlaceContentRequest previous;
-        QPlaceContentRequest next;
-
-        parseCollection(request().contentType(), object, &collection, &totalCount,
-                        &previous, &next, m_engine);
-
-        setTotalCount(totalCount);
-        setContent(collection);
-        setPreviousPageRequest(previous);
-        setNextPageRequest(next);
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
+
+    if (reply->error() != QNetworkReply::NoError)
+        return;
+
+    QJsonDocument document = QJsonDocument::fromJson(reply->readAll());
+    if (!document.isObject()) {
+        setError(ParseError, QCoreApplication::translate(NOKIA_PLUGIN_CONTEXT_NAME, PARSE_ERROR));
+        return;
     }
 
-    m_reply->deleteLater();
-    m_reply = 0;
+    QJsonObject object = document.object();
+
+    QPlaceContent::Collection collection;
+    int totalCount;
+    QPlaceContentRequest previous;
+    QPlaceContentRequest next;
+
+    parseCollection(request().contentType(), object, &collection, &totalCount,
+                    &previous, &next, m_engine);
+
+    setTotalCount(totalCount);
+    setContent(collection);
+    setPreviousPageRequest(previous);
+    setNextPageRequest(next);
 
     setFinished(true);
     emit finished();
@@ -114,13 +111,12 @@ void QPlaceContentReplyImpl::replyFinished()
 
 void QPlaceContentReplyImpl::replyError(QNetworkReply::NetworkError error)
 {
-    switch (error) {
-    case QNetworkReply::OperationCanceledError:
-        setError(CancelError, "Request canceled.");
-        break;
-    default:
-        setError(CommunicationError, "Network error.");
-    }
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
+    if (error == QNetworkReply::OperationCanceledError)
+        setError(QPlaceReply::CancelError, QStringLiteral("Request cancelled"));
+    else
+        setError(QPlaceReply::CommunicationError, reply->errorString());
 }
 
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/nokia/placesv2/qplacecontentreplyimpl.h b/src/plugins/geoservices/nokia/placesv2/qplacecontentreplyimpl.h
index c7ef7ee4..596b9a4c 100644
--- a/src/plugins/geoservices/nokia/placesv2/qplacecontentreplyimpl.h
+++ b/src/plugins/geoservices/nokia/placesv2/qplacecontentreplyimpl.h
@@ -54,15 +54,12 @@ public:
                            QPlaceManagerEngineNokiaV2 *engine);
     ~QPlaceContentReplyImpl();
 
-    void abort();
-
 private slots:
     void setError(QPlaceReply::Error error_, const QString &errorString);
     void replyFinished();
     void replyError(QNetworkReply::NetworkError error);
 
 private:
-    QNetworkReply *m_reply;
     QPlaceManagerEngineNokiaV2 *m_engine;
 };
 
diff --git a/src/plugins/geoservices/nokia/placesv2/qplacedetailsreplyimpl.cpp b/src/plugins/geoservices/nokia/placesv2/qplacedetailsreplyimpl.cpp
index e85b9cc7..1e7f2d2f 100644
--- a/src/plugins/geoservices/nokia/placesv2/qplacedetailsreplyimpl.cpp
+++ b/src/plugins/geoservices/nokia/placesv2/qplacedetailsreplyimpl.cpp
@@ -88,27 +88,23 @@ static bool countryTableContains(const QString &countryCode)
 
 QPlaceDetailsReplyImpl::QPlaceDetailsReplyImpl(QNetworkReply *reply,
                                                QPlaceManagerEngineNokiaV2 *parent)
-    :   QPlaceDetailsReply(parent), m_reply(reply), m_engine(parent)
+:   QPlaceDetailsReply(parent), m_engine(parent)
 {
-    Q_ASSERT(parent);
-
-    if (!m_reply)
+    if (!reply) {
+        setError(UnknownError, QStringLiteral("Null reply"));
         return;
-
-    m_reply->setParent(this);
-    connect(m_reply, SIGNAL(finished()), this, SLOT(replyFinished()));
+    }
+    connect(reply, SIGNAL(finished()), this, SLOT(replyFinished()));
+    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
+            this, SLOT(replyError(QNetworkReply::NetworkError)));
+    connect(this, &QPlaceReply::aborted, reply, &QNetworkReply::abort);
+    connect(this, &QObject::destroyed, reply, &QObject::deleteLater);
 }
 
 QPlaceDetailsReplyImpl::~QPlaceDetailsReplyImpl()
 {
 }
 
-void QPlaceDetailsReplyImpl::abort()
-{
-    if (m_reply)
-        m_reply->abort();
-}
-
 void QPlaceDetailsReplyImpl::setError(QPlaceReply::Error error_, const QString &errorString)
 {
     QPlaceReply::setError(error_, errorString);
@@ -119,23 +115,13 @@ void QPlaceDetailsReplyImpl::setError(QPlaceReply::Error error_, const QString &
 
 void QPlaceDetailsReplyImpl::replyFinished()
 {
-    if (m_reply->error() != QNetworkReply::NoError) {
-        switch (m_reply->error()) {
-        case QNetworkReply::OperationCanceledError:
-            setError(CancelError, "Request canceled.");
-            break;
-        case QNetworkReply::ContentNotFoundError:
-            setError(PlaceDoesNotExistError,
-                     QString::fromLatin1("The id, %1, does not reference an existing place")
-                     .arg(m_placeId));
-            break;
-        default:
-            setError(CommunicationError, "Network error.");
-        }
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
+
+    if (reply->error() != QNetworkReply::NoError)
         return;
-    }
 
-    QJsonDocument document = QJsonDocument::fromJson(m_reply->readAll());
+    QJsonDocument document = QJsonDocument::fromJson(reply->readAll());
     if (!document.isObject()) {
         setError(ParseError, QCoreApplication::translate(NOKIA_PLUGIN_CONTEXT_NAME, PARSE_ERROR));
         return;
@@ -337,11 +323,23 @@ void QPlaceDetailsReplyImpl::replyFinished()
     place.setDetailsFetched(true);
     setPlace(place);
 
-    m_reply->deleteLater();
-    m_reply = 0;
-
     setFinished(true);
     emit finished();
 }
 
+void QPlaceDetailsReplyImpl::replyError(QNetworkReply::NetworkError error)
+{
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
+    if (error == QNetworkReply::OperationCanceledError) {
+        setError(QPlaceReply::CancelError, QStringLiteral("Request cancelled"));
+    } else if (error == QNetworkReply::ContentNotFoundError) {
+        setError(QPlaceReply::PlaceDoesNotExistError,
+                 QString::fromLatin1("The id, %1, does not reference an existing place")
+                 .arg(m_placeId));
+    } else {
+        setError(QPlaceReply::CommunicationError, reply->errorString());
+    }
+}
+
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/nokia/placesv2/qplacedetailsreplyimpl.h b/src/plugins/geoservices/nokia/placesv2/qplacedetailsreplyimpl.h
index 2524d04a..dc537c80 100644
--- a/src/plugins/geoservices/nokia/placesv2/qplacedetailsreplyimpl.h
+++ b/src/plugins/geoservices/nokia/placesv2/qplacedetailsreplyimpl.h
@@ -53,15 +53,14 @@ public:
     QPlaceDetailsReplyImpl(QNetworkReply *reply, QPlaceManagerEngineNokiaV2 *parent);
     ~QPlaceDetailsReplyImpl();
 
-    void abort();
     void setPlaceId(const QString &placeId) { m_placeId = placeId; }
 
 private slots:
     void setError(QPlaceReply::Error error_, const QString &errorString);
     void replyFinished();
+    void replyError(QNetworkReply::NetworkError error);
 
 private:
-    QNetworkReply *m_reply;
     QPlaceManagerEngineNokiaV2 *m_engine;
     QString m_placeId;
 };
diff --git a/src/plugins/geoservices/nokia/placesv2/qplacesearchreplyhere.cpp b/src/plugins/geoservices/nokia/placesv2/qplacesearchreplyhere.cpp
index 3a56c927..9808b539 100644
--- a/src/plugins/geoservices/nokia/placesv2/qplacesearchreplyhere.cpp
+++ b/src/plugins/geoservices/nokia/placesv2/qplacesearchreplyhere.cpp
@@ -54,29 +54,25 @@ QT_BEGIN_NAMESPACE
 QPlaceSearchReplyHere::QPlaceSearchReplyHere(const QPlaceSearchRequest &request,
                                              QNetworkReply *reply,
                                              QPlaceManagerEngineNokiaV2 *parent)
-    :   QPlaceSearchReply(parent), m_reply(reply), m_engine(parent)
+    :   QPlaceSearchReply(parent), m_engine(parent)
 {
-    Q_ASSERT(parent);
-
-    setRequest(request);
-
-    if (!m_reply)
+    if (!reply) {
+        setError(UnknownError, QStringLiteral("Null reply"));
         return;
+    }
+    setRequest(request);
 
-    m_reply->setParent(this);
-    connect(m_reply, SIGNAL(finished()), this, SLOT(replyFinished()));
+    connect(reply, SIGNAL(finished()), this, SLOT(replyFinished()));
+    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
+            this, SLOT(replyError(QNetworkReply::NetworkError)));
+    connect(this, &QPlaceReply::aborted, reply, &QNetworkReply::abort);
+    connect(this, &QObject::destroyed, reply, &QObject::deleteLater);
 }
 
 QPlaceSearchReplyHere::~QPlaceSearchReplyHere()
 {
 }
 
-void QPlaceSearchReplyHere::abort()
-{
-    if (m_reply)
-        m_reply->abort();
-}
-
 void QPlaceSearchReplyHere::setError(QPlaceReply::Error error_, const QString &errorString)
 {
     QPlaceReply::setError(error_, errorString);
@@ -87,23 +83,13 @@ void QPlaceSearchReplyHere::setError(QPlaceReply::Error error_, const QString &e
 
 void QPlaceSearchReplyHere::replyFinished()
 {
-    if (m_reply->error() != QNetworkReply::NoError) {
-        switch (m_reply->error()) {
-        case QNetworkReply::OperationCanceledError:
-            setError(CancelError, QCoreApplication::translate(NOKIA_PLUGIN_CONTEXT_NAME, CANCEL_ERROR));
-            break;
-        case QNetworkReply::ContentNotFoundError:
-            setError(PlaceDoesNotExistError,
-                     QString::fromLatin1("The id, %1, does not reference an existing place")
-                     .arg(request().recommendationId()));
-            break;
-        default:
-            setError(CommunicationError, QCoreApplication::translate(NOKIA_PLUGIN_CONTEXT_NAME, NETWORK_ERROR));
-        }
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
+
+    if (reply->error() != QNetworkReply::NoError)
         return;
-    }
 
-    QJsonDocument document = QJsonDocument::fromJson(m_reply->readAll());
+    QJsonDocument document = QJsonDocument::fromJson(reply->readAll());
     if (!document.isObject()) {
         setError(ParseError, QCoreApplication::translate(NOKIA_PLUGIN_CONTEXT_NAME, PARSE_ERROR));
         return;
@@ -141,9 +127,6 @@ void QPlaceSearchReplyHere::replyFinished()
 
     setResults(results);
 
-    m_reply->deleteLater();
-    m_reply = 0;
-
     setFinished(true);
     emit finished();
 }
@@ -227,4 +210,19 @@ QPlaceProposedSearchResult QPlaceSearchReplyHere::parseSearchResult(const QJsonO
     return result;
 }
 
+void QPlaceSearchReplyHere::replyError(QNetworkReply::NetworkError error)
+{
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
+    if (error == QNetworkReply::OperationCanceledError) {
+        setError(QPlaceReply::CancelError, QCoreApplication::translate(NOKIA_PLUGIN_CONTEXT_NAME, CANCEL_ERROR));
+    } else if (error == QNetworkReply::ContentNotFoundError) {
+        setError(QPlaceReply::PlaceDoesNotExistError,
+                 QString::fromLatin1("The id, %1, does not reference an existing place")
+                 .arg(request().recommendationId()));
+    } else {
+        setError(QPlaceReply::CommunicationError, QCoreApplication::translate(NOKIA_PLUGIN_CONTEXT_NAME, NETWORK_ERROR));
+    }
+}
+
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/nokia/placesv2/qplacesearchreplyhere.h b/src/plugins/geoservices/nokia/placesv2/qplacesearchreplyhere.h
index a712ab84..b3d97a3d 100644
--- a/src/plugins/geoservices/nokia/placesv2/qplacesearchreplyhere.h
+++ b/src/plugins/geoservices/nokia/placesv2/qplacesearchreplyhere.h
@@ -56,17 +56,15 @@ public:
                                    QPlaceManagerEngineNokiaV2 *parent);
     ~QPlaceSearchReplyHere();
 
-    void abort();
-
 private slots:
     void setError(QPlaceReply::Error error_, const QString &errorString);
     void replyFinished();
+    void replyError(QNetworkReply::NetworkError error);
 
 private:
     QPlaceResult parsePlaceResult(const QJsonObject &item) const;
     QPlaceProposedSearchResult parseSearchResult(const QJsonObject &item) const;
 
-    QNetworkReply *m_reply;
     QPlaceManagerEngineNokiaV2 *m_engine;
 };
 
diff --git a/src/plugins/geoservices/nokia/placesv2/qplacesearchsuggestionreplyimpl.cpp b/src/plugins/geoservices/nokia/placesv2/qplacesearchsuggestionreplyimpl.cpp
index 6ed8b5a2..9882545d 100644
--- a/src/plugins/geoservices/nokia/placesv2/qplacesearchsuggestionreplyimpl.cpp
+++ b/src/plugins/geoservices/nokia/placesv2/qplacesearchsuggestionreplyimpl.cpp
@@ -46,25 +46,23 @@ QT_BEGIN_NAMESPACE
 
 QPlaceSearchSuggestionReplyImpl::QPlaceSearchSuggestionReplyImpl(QNetworkReply *reply,
                                                                  QObject *parent)
-:   QPlaceSearchSuggestionReply(parent), m_reply(reply)
+:   QPlaceSearchSuggestionReply(parent)
 {
-    if (!m_reply)
+    if (!reply) {
+        setError(UnknownError, QStringLiteral("Null reply"));
         return;
-
-    m_reply->setParent(this);
-    connect(m_reply, SIGNAL(finished()), this, SLOT(replyFinished()));
+    }
+    connect(reply, SIGNAL(finished()), this, SLOT(replyFinished()));
+    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
+            this, SLOT(replyError(QNetworkReply::NetworkError)));
+    connect(this, &QPlaceReply::aborted, reply, &QNetworkReply::abort);
+    connect(this, &QObject::destroyed, reply, &QObject::deleteLater);
 }
 
 QPlaceSearchSuggestionReplyImpl::~QPlaceSearchSuggestionReplyImpl()
 {
 }
 
-void QPlaceSearchSuggestionReplyImpl::abort()
-{
-    if (m_reply)
-        m_reply->abort();
-}
-
 void QPlaceSearchSuggestionReplyImpl::setError(QPlaceReply::Error error_,
                                                const QString &errorString)
 {
@@ -76,18 +74,13 @@ void QPlaceSearchSuggestionReplyImpl::setError(QPlaceReply::Error error_,
 
 void QPlaceSearchSuggestionReplyImpl::replyFinished()
 {
-    if (m_reply->error() != QNetworkReply::NoError) {
-        switch (m_reply->error()) {
-        case QNetworkReply::OperationCanceledError:
-            setError(CancelError, "Request canceled.");
-            break;
-        default:
-            setError(CommunicationError, "Network error.");
-        }
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
+
+    if (reply->error() != QNetworkReply::NoError)
         return;
-    }
 
-    QJsonDocument document = QJsonDocument::fromJson(m_reply->readAll());
+    QJsonDocument document = QJsonDocument::fromJson(reply->readAll());
     if (!document.isObject()) {
         setError(ParseError, QCoreApplication::translate(NOKIA_PLUGIN_CONTEXT_NAME, PARSE_ERROR));
         emit error(error(), errorString());
@@ -107,11 +100,18 @@ void QPlaceSearchSuggestionReplyImpl::replyFinished()
 
     setSuggestions(s);
 
-    m_reply->deleteLater();
-    m_reply = 0;
-
     setFinished(true);
     emit finished();
 }
 
+void QPlaceSearchSuggestionReplyImpl::replyError(QNetworkReply::NetworkError error)
+{
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
+    if (error == QNetworkReply::OperationCanceledError)
+        setError(QPlaceReply::CancelError, QCoreApplication::translate(NOKIA_PLUGIN_CONTEXT_NAME, CANCEL_ERROR));
+    else
+        setError(QPlaceReply::CommunicationError, QCoreApplication::translate(NOKIA_PLUGIN_CONTEXT_NAME, NETWORK_ERROR));
+}
+
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/nokia/placesv2/qplacesearchsuggestionreplyimpl.h b/src/plugins/geoservices/nokia/placesv2/qplacesearchsuggestionreplyimpl.h
index dbcba3ab..97ae3e1e 100644
--- a/src/plugins/geoservices/nokia/placesv2/qplacesearchsuggestionreplyimpl.h
+++ b/src/plugins/geoservices/nokia/placesv2/qplacesearchsuggestionreplyimpl.h
@@ -50,14 +50,10 @@ public:
     explicit QPlaceSearchSuggestionReplyImpl(QNetworkReply *reply, QObject *parent = 0);
     ~QPlaceSearchSuggestionReplyImpl();
 
-    void abort();
-
 private slots:
     void setError(QPlaceReply::Error error_, const QString &errorString);
     void replyFinished();
-
-private:
-    QNetworkReply *m_reply;
+    void replyError(QNetworkReply::NetworkError error);
 };
 
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/nokia/qgeocodereply_nokia.cpp b/src/plugins/geoservices/nokia/qgeocodereply_nokia.cpp
index 73d2d4c3..53a28652 100644
--- a/src/plugins/geoservices/nokia/qgeocodereply_nokia.cpp
+++ b/src/plugins/geoservices/nokia/qgeocodereply_nokia.cpp
@@ -47,13 +47,21 @@ QT_BEGIN_NAMESPACE
 
 QGeoCodeReplyNokia::QGeoCodeReplyNokia(QNetworkReply *reply, int limit, int offset,
                                        const QGeoShape &viewport, QObject *parent)
-:   QGeoCodeReply(parent), m_reply(reply), m_parsing(false)
+:   QGeoCodeReply(parent), m_parsing(false)
 {
+    if (!reply) {
+        setError(UnknownError, QStringLiteral("Null reply"));
+        return;
+    }
     qRegisterMetaType<QList<QGeoLocation> >();
 
-    connect(m_reply, SIGNAL(finished()), this, SLOT(networkFinished()));
-    connect(m_reply, SIGNAL(error(QNetworkReply::NetworkError)),
+    connect(reply, SIGNAL(finished()), this, SLOT(networkFinished()));
+    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
             this, SLOT(networkError(QNetworkReply::NetworkError)));
+    connect(this, &QGeoCodeReply::aborted, reply, &QNetworkReply::abort);
+    connect(this, &QGeoCodeReply::aborted, [this](){ m_parsing = false; });
+    connect(this, &QObject::destroyed, reply, &QObject::deleteLater);
+
 
     setLimit(limit);
     setOffset(offset);
@@ -62,29 +70,14 @@ QGeoCodeReplyNokia::QGeoCodeReplyNokia(QNetworkReply *reply, int limit, int offs
 
 QGeoCodeReplyNokia::~QGeoCodeReplyNokia()
 {
-    abort();
-}
-
-void QGeoCodeReplyNokia::abort()
-{
-    if (!m_reply) {
-        m_parsing = false;
-        return;
-    }
-
-    m_reply->abort();
-
-    m_reply->deleteLater();
-    m_reply = 0;
-    m_parsing = false;
 }
 
 void QGeoCodeReplyNokia::networkFinished()
 {
-    if (!m_reply)
-        return;
+    QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
 
-    if (m_reply->error() != QNetworkReply::NoError)
+    if (reply->error() != QNetworkReply::NoError)
         return;
 
     QGeoCodeXmlParser *parser = new QGeoCodeXmlParser;
@@ -94,23 +87,16 @@ void QGeoCodeReplyNokia::networkFinished()
     connect(parser, SIGNAL(error(QString)), this, SLOT(parseError(QString)));
 
     m_parsing = true;
-    parser->parse(m_reply->readAll());
-
-    m_reply->deleteLater();
-    m_reply = 0;
+    parser->parse(reply->readAll());
 }
 
 void QGeoCodeReplyNokia::networkError(QNetworkReply::NetworkError error)
 {
     Q_UNUSED(error)
 
-    if (!m_reply)
-        return;
-
-    setError(QGeoCodeReply::CommunicationError, m_reply->errorString());
-
-    m_reply->deleteLater();
-    m_reply = 0;
+    QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
+    setError(QGeoCodeReply::CommunicationError, reply->errorString());
 }
 
 void QGeoCodeReplyNokia::appendResults(const QList<QGeoLocation> &locations)
@@ -129,7 +115,6 @@ void QGeoCodeReplyNokia::parseError(const QString &errorString)
 
     setError(QGeoCodeReply::ParseError,
              QCoreApplication::translate(NOKIA_PLUGIN_CONTEXT_NAME, RESPONSE_NOT_RECOGNIZABLE));
-    abort();
 }
 
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/nokia/qgeocodereply_nokia.h b/src/plugins/geoservices/nokia/qgeocodereply_nokia.h
index 85726fca..43730403 100644
--- a/src/plugins/geoservices/nokia/qgeocodereply_nokia.h
+++ b/src/plugins/geoservices/nokia/qgeocodereply_nokia.h
@@ -49,8 +49,6 @@ public:
     QGeoCodeReplyNokia(QNetworkReply *reply, int limit, int offset, const QGeoShape &viewport, QObject *parent = 0);
     ~QGeoCodeReplyNokia();
 
-    void abort();
-
 private Q_SLOTS:
     void networkFinished();
     void networkError(QNetworkReply::NetworkError error);
@@ -58,7 +56,6 @@ private Q_SLOTS:
     void parseError(const QString &errorString);
 
 private:
-    QNetworkReply *m_reply;
     bool m_parsing;
 };
 
diff --git a/src/plugins/geoservices/nokia/qgeomapreply_nokia.cpp b/src/plugins/geoservices/nokia/qgeomapreply_nokia.cpp
index c95f8de3..6e1a1e85 100644
--- a/src/plugins/geoservices/nokia/qgeomapreply_nokia.cpp
+++ b/src/plugins/geoservices/nokia/qgeomapreply_nokia.cpp
@@ -42,63 +42,50 @@
 QT_BEGIN_NAMESPACE
 
 QGeoMapReplyNokia::QGeoMapReplyNokia(QNetworkReply *reply, const QGeoTileSpec &spec, QObject *parent)
-        : QGeoTiledMapReply(spec, parent),
-        m_reply(reply)
+        : QGeoTiledMapReply(spec, parent)
 {
-    connect(m_reply,
+    if (!reply) {
+        setError(UnknownError, QStringLiteral("Null reply"));
+        return;
+    }
+    connect(reply,
             SIGNAL(finished()),
             this,
             SLOT(networkFinished()));
 
-    connect(m_reply,
+    connect(reply,
             SIGNAL(error(QNetworkReply::NetworkError)),
             this,
             SLOT(networkError(QNetworkReply::NetworkError)));
+    connect(this, &QGeoTiledMapReply::aborted, reply, &QNetworkReply::abort);
+    connect(this, &QObject::destroyed, reply, &QObject::deleteLater);
 }
 
 QGeoMapReplyNokia::~QGeoMapReplyNokia()
 {
 }
 
-QNetworkReply *QGeoMapReplyNokia::networkReply() const
-{
-    return m_reply;
-}
-
-void QGeoMapReplyNokia::abort()
-{
-    if (!m_reply)
-        return;
-
-    m_reply->abort();
-}
-
 void QGeoMapReplyNokia::networkFinished()
 {
-    if (!m_reply)
-        return;
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
 
-    if (m_reply->error() != QNetworkReply::NoError)
+    if (reply->error() != QNetworkReply::NoError)
         return;
 
-    setMapImageData(m_reply->readAll());
+    setMapImageData(reply->readAll());
     setMapImageFormat("png");
     setFinished(true);
-
-    m_reply->deleteLater();
-    m_reply = 0;
 }
 
 void QGeoMapReplyNokia::networkError(QNetworkReply::NetworkError error)
 {
-    if (!m_reply)
-        return;
-
-    if (error != QNetworkReply::OperationCanceledError)
-        setError(QGeoTiledMapReply::CommunicationError, m_reply->errorString());
-    setFinished(true);
-    m_reply->deleteLater();
-    m_reply = 0;
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
+    if (error == QNetworkReply::OperationCanceledError)
+        setFinished(true);
+    else
+        setError(QGeoTiledMapReply::CommunicationError, reply->errorString());
 }
 
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/nokia/qgeomapreply_nokia.h b/src/plugins/geoservices/nokia/qgeomapreply_nokia.h
index 55759914..d835757c 100644
--- a/src/plugins/geoservices/nokia/qgeomapreply_nokia.h
+++ b/src/plugins/geoservices/nokia/qgeomapreply_nokia.h
@@ -52,16 +52,9 @@ public:
     QGeoMapReplyNokia(QNetworkReply *reply, const QGeoTileSpec &spec, QObject *parent = 0);
     ~QGeoMapReplyNokia();
 
-    void abort();
-
-    QNetworkReply *networkReply() const;
-
 private Q_SLOTS:
     void networkFinished();
     void networkError(QNetworkReply::NetworkError error);
-
-private:
-    QPointer<QNetworkReply> m_reply;
 };
 
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/nokia/qgeoroutereply_nokia.cpp b/src/plugins/geoservices/nokia/qgeoroutereply_nokia.cpp
index 45ea071f..b5fdfee1 100644
--- a/src/plugins/geoservices/nokia/qgeoroutereply_nokia.cpp
+++ b/src/plugins/geoservices/nokia/qgeoroutereply_nokia.cpp
@@ -49,43 +49,41 @@ QT_BEGIN_NAMESPACE
 QGeoRouteReplyNokia::QGeoRouteReplyNokia(const QGeoRouteRequest &request,
                                          const QList<QNetworkReply *> &replies,
                                          QObject *parent)
-:   QGeoRouteReply(request, parent), m_replies(replies), m_parsers(0)
+:   QGeoRouteReply(request, parent), m_parsers(0)
 {
     qRegisterMetaType<QList<QGeoRoute> >();
 
-    foreach (QNetworkReply *reply, m_replies) {
+    bool failure = false;
+    foreach (QNetworkReply *reply, replies) {
+        if (!reply) {
+            failure = true;
+            continue;
+        }
         connect(reply, SIGNAL(finished()), this, SLOT(networkFinished()));
         connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
                 this, SLOT(networkError(QNetworkReply::NetworkError)));
+        connect(this, &QGeoRouteReply::aborted, reply, &QNetworkReply::abort);
+        connect(this, &QObject::destroyed, reply, &QObject::deleteLater);
     }
+    if (failure)
+        setError(UnknownError, QStringLiteral("Null reply"));
+    else
+        connect(this, &QGeoRouteReply::aborted, [this](){ m_parsers = 0; });
 }
 
 QGeoRouteReplyNokia::~QGeoRouteReplyNokia()
 {
-    abort();
-}
-
-void QGeoRouteReplyNokia::abort()
-{
-    if (m_replies.isEmpty() && !m_parsers)
-        return;
-
-    foreach (QNetworkReply *reply, m_replies) {
-        reply->abort();
-        reply->deleteLater();
-    }
-    m_replies.clear();
-    m_parsers = 0;
 }
 
 void QGeoRouteReplyNokia::networkFinished()
 {
     QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender());
-    if (!reply)
-        return;
+    reply->deleteLater();
 
-    if (reply->error() != QNetworkReply::NoError)
+    if (reply->error() != QNetworkReply::NoError
+        && reply->error() != QNetworkReply::UnknownContentError) {
         return;
+    }
 
     QGeoRouteXmlParser *parser = new QGeoRouteXmlParser(request());
     connect(parser, SIGNAL(results(QList<QGeoRoute>)),
@@ -94,32 +92,17 @@ void QGeoRouteReplyNokia::networkFinished()
 
     ++m_parsers;
     parser->parse(reply->readAll());
-
-    m_replies.removeOne(reply);
-    reply->deleteLater();
 }
 
 void QGeoRouteReplyNokia::networkError(QNetworkReply::NetworkError error)
 {
-    QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender());
-    if (!reply)
+    if (error == QNetworkReply::UnknownContentError)
         return;
-
-    if (error == QNetworkReply::UnknownContentError) {
-        QGeoRouteXmlParser *parser = new QGeoRouteXmlParser(request());
-        connect(parser, SIGNAL(results(QList<QGeoRoute>)),
-                this, SLOT(appendResults(QList<QGeoRoute>)));
-        connect(parser, SIGNAL(error(QString)), this, SLOT(parserError(QString)));
-
-        ++m_parsers;
-        parser->parse(reply->readAll());
-
-        m_replies.removeOne(reply);
-        reply->deleteLater();
-    } else {
-        setError(QGeoRouteReply::CommunicationError, reply->errorString());
-        abort();
-    }
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
+    setError(QGeoRouteReply::CommunicationError, reply->errorString());
+    if (error != QNetworkReply::OperationCanceledError) // Any error not caused by abort()
+        emit aborted(); // aborts all unfinished replies and sets m_parsers to 0
 }
 
 void QGeoRouteReplyNokia::appendResults(const QList<QGeoRoute> &routes)
@@ -130,19 +113,16 @@ void QGeoRouteReplyNokia::appendResults(const QList<QGeoRoute> &routes)
     --m_parsers;
     addRoutes(routes);
 
-    if (!m_parsers && m_replies.isEmpty())
+    if (!m_parsers)
         setFinished(true);
 }
 
 void QGeoRouteReplyNokia::parserError(const QString &errorString)
 {
     Q_UNUSED(errorString)
-
-    --m_parsers;
-
+    emit aborted();
     setError(QGeoRouteReply::ParseError,
              QCoreApplication::translate(NOKIA_PLUGIN_CONTEXT_NAME, RESPONSE_NOT_RECOGNIZABLE));
-    abort();
 }
 
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/nokia/qgeoroutereply_nokia.h b/src/plugins/geoservices/nokia/qgeoroutereply_nokia.h
index 9d32bdb3..d38262a5 100644
--- a/src/plugins/geoservices/nokia/qgeoroutereply_nokia.h
+++ b/src/plugins/geoservices/nokia/qgeoroutereply_nokia.h
@@ -51,8 +51,6 @@ public:
     QGeoRouteReplyNokia(const QGeoRouteRequest &request, const QList<QNetworkReply*> &replies, QObject *parent = 0);
     ~QGeoRouteReplyNokia();
 
-    void abort();
-
 private Q_SLOTS:
     void networkFinished();
     void networkError(QNetworkReply::NetworkError error);
@@ -60,7 +58,6 @@ private Q_SLOTS:
     void parserError(const QString &errorString);
 
 private:
-    QList<QNetworkReply *> m_replies;
     int m_parsers;
 };
 
diff --git a/src/plugins/geoservices/osm/qgeocodereplyosm.cpp b/src/plugins/geoservices/osm/qgeocodereplyosm.cpp
index 15b1724e..a30601d0 100644
--- a/src/plugins/geoservices/osm/qgeocodereplyosm.cpp
+++ b/src/plugins/geoservices/osm/qgeocodereplyosm.cpp
@@ -50,31 +50,23 @@
 QT_BEGIN_NAMESPACE
 
 QGeoCodeReplyOsm::QGeoCodeReplyOsm(QNetworkReply *reply, QObject *parent)
-:   QGeoCodeReply(parent), m_reply(reply)
+:   QGeoCodeReply(parent)
 {
-    connect(m_reply, SIGNAL(finished()), this, SLOT(networkReplyFinished()));
-    connect(m_reply, SIGNAL(error(QNetworkReply::NetworkError)),
+    if (!reply) {
+        setError(UnknownError, QStringLiteral("Null reply"));
+        return;
+    }
+    connect(reply, SIGNAL(finished()), this, SLOT(networkReplyFinished()));
+    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
             this, SLOT(networkReplyError(QNetworkReply::NetworkError)));
-
+    connect(this, &QGeoCodeReply::aborted, reply, &QNetworkReply::abort);
+    connect(this, &QObject::destroyed, reply, &QObject::deleteLater);
     setLimit(1);
     setOffset(0);
 }
 
 QGeoCodeReplyOsm::~QGeoCodeReplyOsm()
 {
-    if (m_reply)
-        m_reply->deleteLater();
-}
-
-void QGeoCodeReplyOsm::abort()
-{
-    if (!m_reply)
-        return;
-
-    m_reply->abort();
-
-    m_reply->deleteLater();
-    m_reply = 0;
 }
 
 static QGeoAddress parseAddressObject(const QJsonObject &object)
@@ -108,14 +100,14 @@ static QGeoAddress parseAddressObject(const QJsonObject &object)
 
 void QGeoCodeReplyOsm::networkReplyFinished()
 {
-    if (!m_reply)
-        return;
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
 
-    if (m_reply->error() != QNetworkReply::NoError)
+    if (reply->error() != QNetworkReply::NoError)
         return;
 
     QList<QGeoLocation> locations;
-    QJsonDocument document = QJsonDocument::fromJson(m_reply->readAll());
+    QJsonDocument document = QJsonDocument::fromJson(reply->readAll());
 
     if (document.isObject()) {
         QJsonObject object = document.object();
@@ -169,22 +161,14 @@ void QGeoCodeReplyOsm::networkReplyFinished()
 
     setLocations(locations);
     setFinished(true);
-
-    m_reply->deleteLater();
-    m_reply = 0;
 }
 
 void QGeoCodeReplyOsm::networkReplyError(QNetworkReply::NetworkError error)
 {
     Q_UNUSED(error)
-
-    if (!m_reply)
-        return;
-
-    setError(QGeoCodeReply::CommunicationError, m_reply->errorString());
-
-    m_reply->deleteLater();
-    m_reply = 0;
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
+    setError(QGeoCodeReply::CommunicationError, reply->errorString());
 }
 
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/osm/qgeocodereplyosm.h b/src/plugins/geoservices/osm/qgeocodereplyosm.h
index 2772910e..0847f58c 100644
--- a/src/plugins/geoservices/osm/qgeocodereplyosm.h
+++ b/src/plugins/geoservices/osm/qgeocodereplyosm.h
@@ -53,14 +53,9 @@ public:
     explicit QGeoCodeReplyOsm(QNetworkReply *reply, QObject *parent = 0);
     ~QGeoCodeReplyOsm();
 
-    void abort();
-
 private Q_SLOTS:
     void networkReplyFinished();
     void networkReplyError(QNetworkReply::NetworkError error);
-
-private:
-    QNetworkReply *m_reply;
 };
 
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/osm/qgeomapreplyosm.cpp b/src/plugins/geoservices/osm/qgeomapreplyosm.cpp
index 052ed351..a06f91f3 100644
--- a/src/plugins/geoservices/osm/qgeomapreplyosm.cpp
+++ b/src/plugins/geoservices/osm/qgeomapreplyosm.cpp
@@ -45,64 +45,45 @@ QGeoMapReplyOsm::QGeoMapReplyOsm(QNetworkReply *reply,
                                  const QGeoTileSpec &spec,
                                  const QString &imageFormat,
                                  QObject *parent)
-:   QGeoTiledMapReply(spec, parent), m_reply(reply)
+:   QGeoTiledMapReply(spec, parent)
 {
-    connect(m_reply, SIGNAL(finished()), this, SLOT(networkReplyFinished()));
-    connect(m_reply, SIGNAL(error(QNetworkReply::NetworkError)),
+    if (!reply) {
+        setError(UnknownError, QStringLiteral("Null reply"));
+        return;
+    }
+    connect(reply, SIGNAL(finished()), this, SLOT(networkReplyFinished()));
+    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
             this, SLOT(networkReplyError(QNetworkReply::NetworkError)));
+    connect(this, &QGeoTiledMapReply::aborted, reply, &QNetworkReply::abort);
+    connect(this, &QObject::destroyed, reply, &QObject::deleteLater);
     setMapImageFormat(imageFormat);
 }
 
 QGeoMapReplyOsm::~QGeoMapReplyOsm()
 {
-    if (m_reply) {
-        m_reply->deleteLater();
-        m_reply = 0;
-    }
-}
-
-void QGeoMapReplyOsm::abort()
-{
-    if (!m_reply)
-        return;
-
-    m_reply->abort();
-}
-
-QNetworkReply *QGeoMapReplyOsm::networkReply() const
-{
-    return m_reply;
 }
 
 void QGeoMapReplyOsm::networkReplyFinished()
 {
-    if (!m_reply)
-        return;
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
 
-    if (m_reply->error() != QNetworkReply::NoError) {
-        m_reply->deleteLater();
-        m_reply = 0;
+    if (reply->error() != QNetworkReply::NoError) // Already handled in networkReplyError
         return;
-    }
 
-    QByteArray a = m_reply->readAll();
+    QByteArray a = reply->readAll();
 
     setMapImageData(a);
     setFinished(true);
-
-    m_reply->deleteLater();
-    m_reply = 0;
 }
 
 void QGeoMapReplyOsm::networkReplyError(QNetworkReply::NetworkError error)
 {
-    if (!m_reply)
-        return;
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
+    if (error == QNetworkReply::OperationCanceledError)
+        setFinished(true);
+    else
+        setError(QGeoTiledMapReply::CommunicationError, reply->errorString());
 
-    if (error != QNetworkReply::OperationCanceledError)
-        setError(QGeoTiledMapReply::CommunicationError, m_reply->errorString());
-
-    setFinished(true);
-    m_reply->deleteLater();
-    m_reply = 0;
 }
diff --git a/src/plugins/geoservices/osm/qgeomapreplyosm.h b/src/plugins/geoservices/osm/qgeomapreplyosm.h
index 804a0a24..ef0cbb15 100644
--- a/src/plugins/geoservices/osm/qgeomapreplyosm.h
+++ b/src/plugins/geoservices/osm/qgeomapreplyosm.h
@@ -40,12 +40,8 @@
 #ifndef QGEOMAPREPLYOSM_H
 #define QGEOMAPREPLYOSM_H
 
-#include "qgeotilefetcherosm.h"
-#include "qgeotileproviderosm.h"
-
 #include <QtNetwork/QNetworkReply>
 #include <QtLocation/private/qgeotiledmapreply_p.h>
-#include <QtCore/qpointer.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -57,16 +53,9 @@ public:
     QGeoMapReplyOsm(QNetworkReply *reply, const QGeoTileSpec &spec, const QString &imageFormat, QObject *parent = 0);
     ~QGeoMapReplyOsm();
 
-    void abort();
-
-    QNetworkReply *networkReply() const;
-
 private Q_SLOTS:
     void networkReplyFinished();
     void networkReplyError(QNetworkReply::NetworkError error);
-
-private:
-    QPointer<QNetworkReply> m_reply;
 };
 
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/osm/qgeoroutereplyosm.cpp b/src/plugins/geoservices/osm/qgeoroutereplyosm.cpp
index da28317f..6924fda7 100644
--- a/src/plugins/geoservices/osm/qgeoroutereplyosm.cpp
+++ b/src/plugins/geoservices/osm/qgeoroutereplyosm.cpp
@@ -44,55 +44,37 @@ QT_BEGIN_NAMESPACE
 
 QGeoRouteReplyOsm::QGeoRouteReplyOsm(QNetworkReply *reply, const QGeoRouteRequest &request,
                                      QObject *parent)
-:   QGeoRouteReply(request, parent), m_reply(reply)
+:   QGeoRouteReply(request, parent)
 {
-    connect(m_reply, SIGNAL(finished()), this, SLOT(networkReplyFinished()));
-    connect(m_reply, SIGNAL(error(QNetworkReply::NetworkError)),
+    if (!reply) {
+        setError(UnknownError, QStringLiteral("Null reply"));
+        return;
+    }
+    connect(reply, SIGNAL(finished()), this, SLOT(networkReplyFinished()));
+    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
             this, SLOT(networkReplyError(QNetworkReply::NetworkError)));
+    connect(this, &QGeoRouteReply::aborted, reply, &QNetworkReply::abort);
+    connect(this, &QObject::destroyed, reply, &QObject::deleteLater);
 }
 
 QGeoRouteReplyOsm::~QGeoRouteReplyOsm()
 {
-    if (m_reply)
-        m_reply->deleteLater();
-}
-
-void QGeoRouteReplyOsm::abort()
-{
-    if (!m_reply)
-        return;
-
-    m_reply->abort();
-
-    m_reply->deleteLater();
-    m_reply = 0;
 }
 
 void QGeoRouteReplyOsm::networkReplyFinished()
 {
-    if (!m_reply)
-        return;
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
 
-    if (m_reply->error() != QNetworkReply::NoError) {
-        setError(QGeoRouteReply::CommunicationError, m_reply->errorString());
-        m_reply->deleteLater();
-        m_reply = 0;
+    if (reply->error() != QNetworkReply::NoError)
         return;
-    }
-
-    if (m_reply->error() != QNetworkReply::NoError) {
-        setError(QGeoRouteReply::CommunicationError, m_reply->errorString());
-        m_reply->deleteLater();
-        m_reply = 0;
-        return;
-    }
 
     QGeoRoutingManagerEngineOsm *engine = qobject_cast<QGeoRoutingManagerEngineOsm *>(parent());
     const QGeoRouteParser *parser = engine->routeParser();
 
     QList<QGeoRoute> routes;
     QString errorString;
-    QGeoRouteReply::Error error = parser->parseReply(routes, errorString, m_reply->readAll());
+    QGeoRouteReply::Error error = parser->parseReply(routes, errorString, reply->readAll());
 
     if (error == QGeoRouteReply::NoError) {
         setRoutes(routes.mid(0,1)); // TODO QTBUG-56426
@@ -101,22 +83,14 @@ void QGeoRouteReplyOsm::networkReplyFinished()
     } else {
         setError(error, errorString);
     }
-
-    m_reply->deleteLater();
-    m_reply = 0;
 }
 
 void QGeoRouteReplyOsm::networkReplyError(QNetworkReply::NetworkError error)
 {
     Q_UNUSED(error)
-
-    if (!m_reply)
-        return;
-
-    setError(QGeoRouteReply::CommunicationError, m_reply->errorString());
-
-    m_reply->deleteLater();
-    m_reply = 0;
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
+    setError(QGeoRouteReply::CommunicationError, reply->errorString());
 }
 
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/osm/qgeoroutereplyosm.h b/src/plugins/geoservices/osm/qgeoroutereplyosm.h
index 8733c154..feaae59c 100644
--- a/src/plugins/geoservices/osm/qgeoroutereplyosm.h
+++ b/src/plugins/geoservices/osm/qgeoroutereplyosm.h
@@ -54,14 +54,9 @@ public:
     QGeoRouteReplyOsm(QNetworkReply *reply, const QGeoRouteRequest &request, QObject *parent = 0);
     ~QGeoRouteReplyOsm();
 
-    void abort() Q_DECL_OVERRIDE;
-
 private Q_SLOTS:
     void networkReplyFinished();
     void networkReplyError(QNetworkReply::NetworkError error);
-
-private:
-    QNetworkReply *m_reply;
 };
 
 QT_END_NAMESPACE
diff --git a/src/plugins/geoservices/osm/qplacemanagerengineosm.cpp b/src/plugins/geoservices/osm/qplacemanagerengineosm.cpp
index 719769f0..dcf02b13 100644
--- a/src/plugins/geoservices/osm/qplacemanagerengineosm.cpp
+++ b/src/plugins/geoservices/osm/qplacemanagerengineosm.cpp
@@ -260,9 +260,6 @@ void QPlaceManagerEngineOsm::setLocales(const QList<QLocale> &locales)
 void QPlaceManagerEngineOsm::categoryReplyFinished()
 {
     QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender());
-    if (!reply)
-        return;
-
     reply->deleteLater();
 
     QXmlStreamReader parser(reply);
diff --git a/src/plugins/geoservices/osm/qplacesearchreplyosm.cpp b/src/plugins/geoservices/osm/qplacesearchreplyosm.cpp
index 3cb0ab60..35b05d4d 100644
--- a/src/plugins/geoservices/osm/qplacesearchreplyosm.cpp
+++ b/src/plugins/geoservices/osm/qplacesearchreplyosm.cpp
@@ -53,32 +53,28 @@ QT_BEGIN_NAMESPACE
 
 QPlaceSearchReplyOsm::QPlaceSearchReplyOsm(const QPlaceSearchRequest &request,
                                              QNetworkReply *reply, QPlaceManagerEngineOsm *parent)
-:   QPlaceSearchReply(parent), m_reply(reply)
+:   QPlaceSearchReply(parent)
 {
     Q_ASSERT(parent);
-
-    setRequest(request);
-
-    if (!m_reply)
+    if (!reply) {
+        setError(UnknownError, QStringLiteral("Null reply"));
         return;
+    }
+    setRequest(request);
 
-    m_reply->setParent(this);
-    connect(m_reply, SIGNAL(finished()), this, SLOT(replyFinished()));
+    connect(reply, SIGNAL(finished()), this, SLOT(replyFinished()));
+    connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(networkError(QNetworkReply::NetworkError)));
+    connect(this, &QPlaceReply::aborted, reply, &QNetworkReply::abort);
+    connect(this, &QObject::destroyed, reply, &QObject::deleteLater);
 }
 
 QPlaceSearchReplyOsm::~QPlaceSearchReplyOsm()
 {
 }
 
-void QPlaceSearchReplyOsm::abort()
-{
-    if (m_reply)
-        m_reply->abort();
-}
-
 void QPlaceSearchReplyOsm::setError(QPlaceReply::Error errorCode, const QString &errorString)
 {
-    QPlaceReply::setError(errorCode, errorString);
+    setError(errorCode, errorString);
     emit error(errorCode, errorString);
     setFinished(true);
     emit finished();
@@ -99,14 +95,11 @@ static QGeoRectangle parseBoundingBox(const QJsonArray &coordinates)
 
 void QPlaceSearchReplyOsm::replyFinished()
 {
-    QNetworkReply *reply = m_reply;
-    m_reply->deleteLater();
-    m_reply = 0;
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
 
-    if (reply->error() != QNetworkReply::NoError) {
-        setError(CommunicationError, tr("Communication error"));
+    if (reply->error() != QNetworkReply::NoError)
         return;
-    }
 
     QJsonDocument document = QJsonDocument::fromJson(reply->readAll());
     if (!document.isArray()) {
@@ -163,6 +156,14 @@ void QPlaceSearchReplyOsm::replyFinished()
     emit finished();
 }
 
+void QPlaceSearchReplyOsm::networkError(QNetworkReply::NetworkError error)
+{
+    Q_UNUSED(error)
+    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());
+    reply->deleteLater();
+    setError(QPlaceReply::CommunicationError, reply->errorString());
+}
+
 QPlaceResult QPlaceSearchReplyOsm::parsePlaceResult(const QJsonObject &item) const
 {
     QPlace place;
diff --git a/src/plugins/geoservices/osm/qplacesearchreplyosm.h b/src/plugins/geoservices/osm/qplacesearchreplyosm.h
index e495d4fa..223e5f0c 100644
--- a/src/plugins/geoservices/osm/qplacesearchreplyosm.h
+++ b/src/plugins/geoservices/osm/qplacesearchreplyosm.h
@@ -41,6 +41,7 @@
 #define QPLACESEARCHREPLYOSM_H
 
 #include <QtLocation/QPlaceSearchReply>
+#include <QNetworkReply>
 
 QT_BEGIN_NAMESPACE
 
@@ -57,16 +58,13 @@ public:
                           QPlaceManagerEngineOsm *parent);
     ~QPlaceSearchReplyOsm();
 
-    void abort();
-
 private slots:
     void setError(QPlaceReply::Error errorCode, const QString &errorString);
     void replyFinished();
+    void networkError(QNetworkReply::NetworkError error);
 
 private:
     QPlaceResult parsePlaceResult(const QJsonObject &item) const;
-
-    QNetworkReply *m_reply;
 };
 
 QT_END_NAMESPACE
diff --git a/tests/auto/geotestplugin/qgeocodingmanagerengine_test.h b/tests/auto/geotestplugin/qgeocodingmanagerengine_test.h
index 1d9f0792..ecbb60d1 100644
--- a/tests/auto/geotestplugin/qgeocodingmanagerengine_test.h
+++ b/tests/auto/geotestplugin/qgeocodingmanagerengine_test.h
@@ -57,11 +57,6 @@ public:
     void  callSetOffset ( int offset ) {setOffset(offset);}
     void  callSetLocations ( const QList<QGeoLocation> & locations ) {setLocations(locations);}
     void  callSetViewport ( const QGeoShape &viewport ) {setViewport(viewport);}
-    void abort() {
-        emit aborted();
-    }
-Q_SIGNALS:
-    void aborted();
 };
 
 class QGeoCodingManagerEngineTest: public QGeoCodingManagerEngine
diff --git a/tests/auto/geotestplugin/qgeoroutingmanagerengine_test.h b/tests/auto/geotestplugin/qgeoroutingmanagerengine_test.h
index 8ae58042..0a1e7ce6 100644
--- a/tests/auto/geotestplugin/qgeoroutingmanagerengine_test.h
+++ b/tests/auto/geotestplugin/qgeoroutingmanagerengine_test.h
@@ -52,12 +52,6 @@ public:
     void  callSetError ( Error error, const QString & errorString ) {setError(error, errorString);}
     void  callSetFinished ( bool finished ) {setFinished(finished);}
     void  callSetRoutes(const QList<QGeoRoute> &routes) {setRoutes(routes);}
-
-    void abort() {
-        emit aborted();
-    }
-Q_SIGNALS:
-    void aborted();
 };
 
 class QGeoRoutingManagerEngineTest: public QGeoRoutingManagerEngine
diff --git a/tests/auto/qgeoroutereply/tst_qgeoroutereply.cpp b/tests/auto/qgeoroutereply/tst_qgeoroutereply.cpp
index 447181f2..de406b40 100644
--- a/tests/auto/qgeoroutereply/tst_qgeoroutereply.cpp
+++ b/tests/auto/qgeoroutereply/tst_qgeoroutereply.cpp
@@ -197,7 +197,7 @@ void tst_QGeoRouteReply::abort()
     reply->abort();
 
     QCOMPARE(signalerror->count(), 0);
-    QCOMPARE(signalfinished->count(), 1);
+    QCOMPARE(signalfinished->count(), 0);
 }
 
 void tst_QGeoRouteReply::error()