Fix some name inconsistencies in QtLocation

1. Rename QGeocoding* classes to QGeoCoding*. This emphasizes the QGeo
prefix rather than the geocing word. The QML interfaces continues to use
the Geocoding* as they don't a prefix as such.

2. Rename QProposedSearchResult to QPlaceProposedSearchResult. The class is place
related and should carry the QPlace name prefix

Change-Id: I428c7e6368774a9f199db5c113de11649e4a665c
Reviewed-by: Kurt Pattyn <pattyn.kurt@gmail.com>
Reviewed-by: Aaron McCarthy <mccarthy.aaron@gmail.com>

48 files changed, 571 insertions, 569 deletions

diff --git a/src/imports/location/declarativeplaces/qdeclarativesearchresultmodel.cpp b/src/imports/location/declarativeplaces/qdeclarativesearchresultmodel.cpp
index 8d182ea8..5d9559cb 100644
--- a/src/imports/location/declarativeplaces/qdeclarativesearchresultmodel.cpp
+++ b/src/imports/location/declarativeplaces/qdeclarativesearchresultmodel.cpp
@@ -51,7 +51,7 @@
 #include <QtLocation/QPlaceMatchRequest>
 #include <QtLocation/QPlaceMatchReply>
 #include <QtLocation/QPlaceResult>
-#include <QtLocation/QProposedSearchResult>
+#include <QtLocation/QPlaceProposedSearchResult>
 
 QT_USE_NAMESPACE
 
@@ -665,7 +665,7 @@ void QDeclarativeSearchResultModel::updateWith(int proposedSearchIndex)
     if (m_results.at(proposedSearchIndex).type() != QPlaceSearchResult::ProposedSearchResult)
         return;
 
-    m_request = QProposedSearchResult(m_results.at(proposedSearchIndex)).searchRequest();
+    m_request = QPlaceProposedSearchResult(m_results.at(proposedSearchIndex)).searchRequest();
     update();
 }
 
diff --git a/src/imports/location/qdeclarativegeocodemodel.cpp b/src/imports/location/qdeclarativegeocodemodel.cpp
index d242ec75..e169e5a6 100644
--- a/src/imports/location/qdeclarativegeocodemodel.cpp
+++ b/src/imports/location/qdeclarativegeocodemodel.cpp
@@ -44,7 +44,7 @@
 
 #include <QtQml/qqmlinfo.h>
 #include <QtLocation/QGeoServiceProvider>
-#include <QtLocation/QGeocodingManager>
+#include <QtLocation/QGeoCodingManager>
 #include <QtPositioning/QGeoCircle>
 
 QT_BEGIN_NAMESPACE
@@ -153,7 +153,7 @@ void QDeclarativeGeocodeModel::update()
     if (!serviceProvider)
         return;
 
-    QGeocodingManager *geocodingManager = serviceProvider->geocodingManager();
+    QGeoCodingManager *geocodingManager = serviceProvider->geocodingManager();
     if (!geocodingManager) {
         qmlInfo(this) << QCoreApplication::translate(CONTEXT_NAME, GEOCODE_MGR_NOT_SET);
         return;
@@ -171,7 +171,7 @@ void QDeclarativeGeocodeModel::update()
         setStatus(QDeclarativeGeocodeModel::Loading);
         reply_ = geocodingManager->reverseGeocode(coordinate_, boundingArea_);
         if (reply_->isFinished()) {
-            if (reply_->error() == QGeocodeReply::NoError) {
+            if (reply_->error() == QGeoCodeReply::NoError) {
                 geocodeFinished(reply_);
             } else {
                 geocodeError(reply_, reply_->error(), reply_->errorString());
@@ -181,7 +181,7 @@ void QDeclarativeGeocodeModel::update()
         setStatus(QDeclarativeGeocodeModel::Loading);
         reply_ = geocodingManager->geocode(address_->address(), boundingArea_);
         if (reply_->isFinished()) {
-            if (reply_->error() == QGeocodeReply::NoError) {
+            if (reply_->error() == QGeoCodeReply::NoError) {
                 geocodeFinished(reply_);
             } else {
                 geocodeError(reply_, reply_->error(), reply_->errorString());
@@ -191,7 +191,7 @@ void QDeclarativeGeocodeModel::update()
         setStatus(QDeclarativeGeocodeModel::Loading);
         reply_ = geocodingManager->geocode(searchString_, limit_, offset_, boundingArea_);
         if (reply_->isFinished()) {
-            if (reply_->error() == QGeocodeReply::NoError) {
+            if (reply_->error() == QGeoCodeReply::NoError) {
                 geocodeFinished(reply_);
             } else {
                 geocodeError(reply_, reply_->error(), reply_->errorString());
@@ -285,15 +285,15 @@ void QDeclarativeGeocodeModel::setPlugin(QDeclarativeGeoServiceProvider *plugin)
 void QDeclarativeGeocodeModel::pluginReady()
 {
     QGeoServiceProvider *serviceProvider = plugin_->sharedGeoServiceProvider();
-    QGeocodingManager *geocodingManager = serviceProvider->geocodingManager();
+    QGeoCodingManager *geocodingManager = serviceProvider->geocodingManager();
     if (!geocodingManager || serviceProvider->error() != QGeoServiceProvider::NoError) {
         qmlInfo(this) << QCoreApplication::translate(CONTEXT_NAME, PLUGIN_DOESNOT_SUPPORT_GEOCODING).arg(serviceProvider->errorString());
         return;
     }
-    connect(geocodingManager, SIGNAL(finished(QGeocodeReply*)),
-            this, SLOT(geocodeFinished(QGeocodeReply*)));
-    connect(geocodingManager, SIGNAL(error(QGeocodeReply*,QGeocodeReply::Error,QString)),
-            this, SLOT(geocodeError(QGeocodeReply*,QGeocodeReply::Error,QString)));
+    connect(geocodingManager, SIGNAL(finished(QGeoCodeReply*)),
+            this, SLOT(geocodeFinished(QGeoCodeReply*)));
+    connect(geocodingManager, SIGNAL(error(QGeoCodeReply*,QGeoCodeReply::Error,QString)),
+            this, SLOT(geocodeError(QGeoCodeReply*,QGeoCodeReply::Error,QString)));
 }
 
 /*!
@@ -350,9 +350,9 @@ QVariant QDeclarativeGeocodeModel::bounds() const
         return QVariant::fromValue(boundingArea_);
 }
 
-void QDeclarativeGeocodeModel::geocodeFinished(QGeocodeReply *reply)
+void QDeclarativeGeocodeModel::geocodeFinished(QGeoCodeReply *reply)
 {
-    if (reply != reply_ || reply->error() != QGeocodeReply::NoError)
+    if (reply != reply_ || reply->error() != QGeoCodeReply::NoError)
         return;
     int oldCount = declarativeLocations_.count();
     setLocations(reply->locations());
@@ -369,8 +369,8 @@ void QDeclarativeGeocodeModel::geocodeFinished(QGeocodeReply *reply)
 /*!
     \internal
 */
-void QDeclarativeGeocodeModel::geocodeError(QGeocodeReply *reply,
-        QGeocodeReply::Error error,
+void QDeclarativeGeocodeModel::geocodeError(QGeoCodeReply *reply,
+        QGeoCodeReply::Error error,
         const QString &errorString)
 {
     if (reply != reply_)
diff --git a/src/imports/location/qdeclarativegeocodemodel_p.h b/src/imports/location/qdeclarativegeocodemodel_p.h
index f5b16a25..2fb9d86b 100644
--- a/src/imports/location/qdeclarativegeocodemodel_p.h
+++ b/src/imports/location/qdeclarativegeocodemodel_p.h
@@ -56,7 +56,7 @@
 QT_BEGIN_NAMESPACE
 
 class QGeoServiceProvider;
-class QGeocodingManager;
+class QGeoCodingManager;
 class QDeclarativeGeoLocation;
 
 class QDeclarativeGeocodeModel : public QAbstractListModel, public QQmlParserStatus
@@ -86,13 +86,13 @@ public:
     };
 
     enum GeocodeError {
-        NoError = QGeocodeReply::NoError,
-        EngineNotSetError = QGeocodeReply::EngineNotSetError,
-        CommunicationError = QGeocodeReply::CommunicationError,
-        ParseError = QGeocodeReply::ParseError,
-        UnsupportedOptionError = QGeocodeReply::UnsupportedOptionError,
-        CombinationError = QGeocodeReply::CombinationError,
-        UnknownError = QGeocodeReply::UnknownError
+        NoError = QGeoCodeReply::NoError,
+        EngineNotSetError = QGeoCodeReply::EngineNotSetError,
+        CommunicationError = QGeoCodeReply::CommunicationError,
+        ParseError = QGeoCodeReply::ParseError,
+        UnsupportedOptionError = QGeoCodeReply::UnsupportedOptionError,
+        CombinationError = QGeoCodeReply::CombinationError,
+        UnknownError = QGeoCodeReply::UnknownError
     };
 
     enum Roles {
@@ -155,14 +155,14 @@ public Q_SLOTS:
 
 protected Q_SLOTS:
     void queryContentChanged();
-    void geocodeFinished(QGeocodeReply *reply);
-    void geocodeError(QGeocodeReply *reply,
-                     QGeocodeReply::Error error,
+    void geocodeFinished(QGeoCodeReply *reply);
+    void geocodeError(QGeoCodeReply *reply,
+                     QGeoCodeReply::Error error,
                      const QString &errorString);
     void pluginReady();
 
 protected:
-    QGeocodingManager *searchManager();
+    QGeoCodingManager *searchManager();
     void setStatus(Status status);
     void setErrorString(const QString &error);
     void setError(GeocodeError error);
@@ -172,7 +172,7 @@ protected:
 private:
     void setLocations(const QList<QGeoLocation> &locations);
     void abortRequest();
-    QGeocodeReply *reply_;
+    QGeoCodeReply *reply_;
 
     QDeclarativeGeoServiceProvider *plugin_;
     QGeoShape boundingArea_;
diff --git a/src/imports/positioning/positioning.pro b/src/imports/positioning/positioning.pro
index 2d396463..1f71f03c 100644
--- a/src/imports/positioning/positioning.pro
+++ b/src/imports/positioning/positioning.pro
@@ -11,8 +11,7 @@ HEADERS += qdeclarativeposition_p.h \
            qdeclarativegeocircle.h \
            locationvaluetypeprovider.h \
            locationsingleton.h \
-           error_messages.h \
-           locationvaluetypehelper_p.h
+           error_messages.h
 
 SOURCES += qdeclarativeposition.cpp \
            positioning.cpp \
diff --git a/src/location/doc/src/maps.qdoc b/src/location/doc/src/maps.qdoc
index 3426d626..a97f28f9 100644
--- a/src/location/doc/src/maps.qdoc
+++ b/src/location/doc/src/maps.qdoc
@@ -220,22 +220,22 @@ must use the \l {Maps and Navigation (QML)} API.
 \section1 Geocoding
 
 In C++, an address-to-coordinate query is performed using the
-\l{QGeocodingManager::geocode()}{geocode()} method of the QGeocodingManager
+\l{QGeoCodingManager::geocode()}{geocode()} method of the QGeoCodingManager
 class. For coordinate-to-address queries, the
-\l{QGeocodingManager::reverseGeocode()}{reverseGeocode()} method is available
-on the same class. Instances of QGeocodingManager are available via
+\l{QGeoCodingManager::reverseGeocode()}{reverseGeocode()} method is available
+on the same class. Instances of QGeoCodingManager are available via
 \l{QGeoServiceProvider}.
 
 \b{Key Classes}
 \table
     \row
         \li \l{QGeoServiceProvider}
-        \li Provides a QGeocodingManager instance ready for use.
+        \li Provides a QGeoCodingManager instance ready for use.
     \row
-        \li \l{QGeocodingManager}
-        \li Accepts queries and produces QGeocodeReply objects.
+        \li \l{QGeoCodingManager}
+        \li Accepts queries and produces QGeoCodeReply objects.
     \row
-        \li \l{QGeocodeReply}
+        \li \l{QGeoCodeReply}
         \li Contains the results of a geocoding query.
 \endtable
 
@@ -249,7 +249,7 @@ multiple routes to the same destination.
 \table
     \row
         \li \l{QGeoServiceProvider}
-        \li Provides a QGeocodingManager instance ready for use.
+        \li Provides a QGeoCodingManager instance ready for use.
     \row
         \li \l{QGeoRoutingManager}
         \li Accepts queries and produces QGeoRouteReply objects.
diff --git a/src/location/maps/qgeocodereply.cpp b/src/location/maps/qgeocodereply.cpp
index 96977799..91738149 100644
--- a/src/location/maps/qgeocodereply.cpp
+++ b/src/location/maps/qgeocodereply.cpp
@@ -44,29 +44,29 @@
 
 QT_BEGIN_NAMESPACE
 /*!
-    \class QGeocodeReply
+    \class QGeoCodeReply
     \inmodule QtLocation
     \ingroup QtLocation-geocoding
     \since Qt Location 5.0
 
-    \brief The QGeocodeReply class manages an operation started by an
-    instance of QGeocodingManager.
+    \brief The QGeoCodeReply class manages an operation started by an
+    instance of QGeoCodingManager.
 
-    Instances of QGeocodeReply manage the state and results of these
+    Instances of QGeoCodeReply manage the state and results of these
     operations.
 
     The isFinished(), error() and errorString() methods provide information
     on whether the operation has completed and if it completed successfully.
 
-    The finished() and error(QGeocodeReply::Error,QString)
+    The finished() and error(QGeoCodeReply::Error,QString)
     signals can be used to monitor the progress of the operation.
 
-    It is possible that a newly created QGeocodeReply may be in a finished
+    It is possible that a newly created QGeoCodeReply may be in a finished
     state, most commonly because an error has occurred. Since such an instance
     will never emit the finished() or
-    error(QGeocodeReply::Error,QString) signals, it is
+    error(QGeoCodeReply::Error,QString) signals, it is
     important to check the result of isFinished() before making the connections
-    to the signals. The documentation for QGeocodingManager demonstrates how
+    to the signals. The documentation for QGeoCodingManager demonstrates how
     this might be carried out.
 
     If the operation completes successfully the results will be able to be
@@ -74,14 +74,14 @@ QT_BEGIN_NAMESPACE
 */
 
 /*!
-    \enum QGeocodeReply::Error
+    \enum QGeoCodeReply::Error
 
     Describes an error which prevented the completion of the operation.
 
     \value NoError
         No error has occurred.
     \value EngineNotSetError
-        The geocoding manager that was used did not have a QGeocodingManagerEngine instance associated with it.
+        The geocoding manager that was used did not have a QGeoCodingManagerEngine instance associated with it.
     \value CommunicationError
         An error occurred while communicating with the service provider.
     \value ParseError
@@ -98,21 +98,21 @@ QT_BEGIN_NAMESPACE
 /*!
     Constructs a geocode reply with the specified \a parent.
 */
-QGeocodeReply::QGeocodeReply(QObject *parent)
+QGeoCodeReply::QGeoCodeReply(QObject *parent)
     : QObject(parent),
-      d_ptr(new QGeocodeReplyPrivate()) {}
+      d_ptr(new QGeoCodeReplyPrivate()) {}
 
 /*!
     Constructs a geocode reply with a given \a error and \a errorString and the specified \a parent.
 */
-QGeocodeReply::QGeocodeReply(Error error, const QString &errorString, QObject *parent)
+QGeoCodeReply::QGeoCodeReply(Error error, const QString &errorString, QObject *parent)
     : QObject(parent),
-      d_ptr(new QGeocodeReplyPrivate(error, errorString)) {}
+      d_ptr(new QGeoCodeReplyPrivate(error, errorString)) {}
 
 /*!
     Destroys this reply object.
 */
-QGeocodeReply::~QGeocodeReply()
+QGeoCodeReply::~QGeoCodeReply()
 {
     delete d_ptr;
 }
@@ -123,11 +123,11 @@ QGeocodeReply::~QGeocodeReply()
     If \a finished is true, this will cause the finished() signal to be
     emitted.
 
-    If the operation completed successfully, QGeocodeReply::setLocations()
+    If the operation completed successfully, QGeoCodeReply::setLocations()
     should be called before this function. If an error occurred,
-    QGeocodeReply::setError() should be used instead.
+    QGeoCodeReply::setError() should be used instead.
 */
-void QGeocodeReply::setFinished(bool finished)
+void QGeoCodeReply::setFinished(bool finished)
 {
     d_ptr->isFinished = finished;
     if (d_ptr->isFinished)
@@ -138,7 +138,7 @@ void QGeocodeReply::setFinished(bool finished)
     Return true if the operation completed successfully or encountered an
     error which cause the operation to come to a halt.
 */
-bool QGeocodeReply::isFinished() const
+bool QGeoCodeReply::isFinished() const
 {
     return d_ptr->isFinished;
 }
@@ -150,7 +150,7 @@ bool QGeocodeReply::isFinished() const
     This will also cause error() and finished() signals to be emitted, in that
     order.
 */
-void QGeocodeReply::setError(QGeocodeReply::Error error, const QString &errorString)
+void QGeoCodeReply::setError(QGeoCodeReply::Error error, const QString &errorString)
 {
     d_ptr->error = error;
     d_ptr->errorString = errorString;
@@ -161,9 +161,9 @@ void QGeocodeReply::setError(QGeocodeReply::Error error, const QString &errorStr
 /*!
     Returns the error state of this reply.
 
-    If the result is QGeocodeReply::NoError then no error has occurred.
+    If the result is QGeoCodeReply::NoError then no error has occurred.
 */
-QGeocodeReply::Error QGeocodeReply::error() const
+QGeoCodeReply::Error QGeoCodeReply::error() const
 {
     return d_ptr->error;
 }
@@ -176,9 +176,9 @@ QGeocodeReply::Error QGeocodeReply::error() const
     which case this will also return an empty string.
 
     To determine whether an error has occurred, check to see if
-    QGeocodeReply::error() is equal to QGeocodeReply::NoError.
+    QGeoCodeReply::error() is equal to QGeoCodeReply::NoError.
 */
-QString QGeocodeReply::errorString() const
+QString QGeoCodeReply::errorString() const
 {
     return d_ptr->errorString;
 }
@@ -186,7 +186,7 @@ QString QGeocodeReply::errorString() const
 /*!
     Sets the viewport which contains the results to \a viewport.
 */
-void QGeocodeReply::setViewport(const QGeoShape &viewport)
+void QGeoCodeReply::setViewport(const QGeoShape &viewport)
 {
     d_ptr->viewport = viewport;
 }
@@ -195,9 +195,9 @@ void QGeocodeReply::setViewport(const QGeoShape &viewport)
     Returns the viewport which contains the results.
 
     This function will return 0 if no viewport bias
-    was specified in the QGeocodingManager function which created this reply.
+    was specified in the QGeoCodingManager function which created this reply.
 */
-QGeoShape QGeocodeReply::viewport() const
+QGeoShape QGeoCodeReply::viewport() const
 {
     return d_ptr->viewport;
 }
@@ -206,9 +206,9 @@ QGeoShape QGeocodeReply::viewport() const
     Returns a list of locations.
 
     The locations are the results of the operation corresponding to the
-    QGeocodingManager function which created this reply.
+    QGeoCodingManager function which created this reply.
 */
-QList<QGeoLocation> QGeocodeReply::locations() const
+QList<QGeoLocation> QGeoCodeReply::locations() const
 {
     return d_ptr->locations;
 }
@@ -216,7 +216,7 @@ QList<QGeoLocation> QGeocodeReply::locations() const
 /*!
     Adds \a location to the list of locations in this reply.
 */
-void QGeocodeReply::addLocation(const QGeoLocation &location)
+void QGeoCodeReply::addLocation(const QGeoLocation &location)
 {
     d_ptr->locations.append(location);
 }
@@ -224,7 +224,7 @@ void QGeocodeReply::addLocation(const QGeoLocation &location)
 /*!
     Sets the list of \a locations in the reply.
 */
-void QGeocodeReply::setLocations(const QList<QGeoLocation> &locations)
+void QGeoCodeReply::setLocations(const QList<QGeoLocation> &locations)
 {
     d_ptr->locations = locations;
 }
@@ -234,7 +234,7 @@ void QGeocodeReply::setLocations(const QList<QGeoLocation> &locations)
 
     This will do nothing if the reply is finished.
 */
-void QGeocodeReply::abort()
+void QGeoCodeReply::abort()
 {
     if (!isFinished())
         setFinished(true);
@@ -248,7 +248,7 @@ void QGeocodeReply::abort()
     This may be more than locations().length() if the number of responses
     was less than the number requested.
 */
-int QGeocodeReply::limit() const
+int QGeoCodeReply::limit() const
 {
     return d_ptr->limit;
 }
@@ -257,7 +257,7 @@ int QGeocodeReply::limit() const
     Returns the offset into the entire result set at which to start
     fetching results.
 */
-int QGeocodeReply::offset() const
+int QGeoCodeReply::offset() const
 {
     return d_ptr->offset;
 }
@@ -267,7 +267,7 @@ int QGeocodeReply::offset() const
 
     If \a limit is -1 then all available responses will be returned.
 */
-void QGeocodeReply::setLimit(int limit)
+void QGeoCodeReply::setLimit(int limit)
 {
     d_ptr->limit = limit;
 }
@@ -276,27 +276,27 @@ void QGeocodeReply::setLimit(int limit)
     Sets the offset in the entire result set at which to start
     fetching result to \a offset.
 */
-void QGeocodeReply::setOffset(int offset)
+void QGeoCodeReply::setOffset(int offset)
 {
     d_ptr->offset = offset;
 }
 
 /*!
-    \fn void QGeocodeReply::finished()
+    \fn void QGeoCodeReply::finished()
 
     This signal is emitted when this reply has finished processing.
 
-    If error() equals QGeocodeReply::NoError then the processing
+    If error() equals QGeoCodeReply::NoError then the processing
     finished successfully.
 
-    This signal and QGeocodingManager::finished() will be
+    This signal and QGeoCodingManager::finished() will be
     emitted at the same time.
 
     \note Do not delete this reply object in the slot connected to this
     signal. Use deleteLater() instead.
 */
 /*!
-    \fn void QGeocodeReply::error(QGeocodeReply::Error error, const QString &errorString)
+    \fn void QGeoCodeReply::error(QGeoCodeReply::Error error, const QString &errorString)
 
     This signal is emitted when an error has been detected in the processing of
     this reply. The finished() signal will probably follow.
@@ -304,7 +304,7 @@ void QGeocodeReply::setOffset(int offset)
     The error will be described by the error code \a error. If \a errorString is
     not empty it will contain a textual description of the error.
 
-    This signal and QGeocodingManager::error() will be emitted at the same time.
+    This signal and QGeoCodingManager::error() will be emitted at the same time.
 
     \note Do not delete this reply object in the slot connected to this
     signal. Use deleteLater() instead.
@@ -313,21 +313,21 @@ void QGeocodeReply::setOffset(int offset)
 /*******************************************************************************
 *******************************************************************************/
 
-QGeocodeReplyPrivate::QGeocodeReplyPrivate()
-    : error(QGeocodeReply::NoError),
+QGeoCodeReplyPrivate::QGeoCodeReplyPrivate()
+    : error(QGeoCodeReply::NoError),
       errorString(QLatin1String("")),
       isFinished(false),
       limit(-1),
       offset(0) {}
 
-QGeocodeReplyPrivate::QGeocodeReplyPrivate(QGeocodeReply::Error error, const QString &errorString)
+QGeoCodeReplyPrivate::QGeoCodeReplyPrivate(QGeoCodeReply::Error error, const QString &errorString)
     : error(error),
       errorString(errorString),
       isFinished(true),
       limit(-1),
       offset(0) {}
 
-QGeocodeReplyPrivate::~QGeocodeReplyPrivate() {}
+QGeoCodeReplyPrivate::~QGeoCodeReplyPrivate() {}
 
 
 #include "moc_qgeocodereply.cpp"
diff --git a/src/location/maps/qgeocodereply.h b/src/location/maps/qgeocodereply.h
index 1f36633f..43055317 100644
--- a/src/location/maps/qgeocodereply.h
+++ b/src/location/maps/qgeocodereply.h
@@ -51,9 +51,9 @@
 QT_BEGIN_NAMESPACE
 
 class QGeoShape;
-class QGeocodeReplyPrivate;
+class QGeoCodeReplyPrivate;
 
-class Q_LOCATION_EXPORT QGeocodeReply : public QObject
+class Q_LOCATION_EXPORT QGeoCodeReply : public QObject
 {
     Q_OBJECT
 
@@ -68,8 +68,8 @@ public:
         UnknownError
     };
 
-    QGeocodeReply(Error error, const QString &errorString, QObject *parent = 0);
-    virtual ~QGeocodeReply();
+    QGeoCodeReply(Error error, const QString &errorString, QObject *parent = 0);
+    virtual ~QGeoCodeReply();
 
     bool isFinished() const;
     Error error() const;
@@ -85,10 +85,10 @@ public:
 
 Q_SIGNALS:
     void finished();
-    void error(QGeocodeReply::Error error, const QString &errorString = QString());
+    void error(QGeoCodeReply::Error error, const QString &errorString = QString());
 
 protected:
-    QGeocodeReply(QObject *parent = 0);
+    QGeoCodeReply(QObject *parent = 0);
 
     void setError(Error error, const QString &errorString);
     void setFinished(bool finished);
@@ -101,8 +101,8 @@ protected:
     void setOffset(int offset);
 
 private:
-    QGeocodeReplyPrivate *d_ptr;
-    Q_DISABLE_COPY(QGeocodeReply)
+    QGeoCodeReplyPrivate *d_ptr;
+    Q_DISABLE_COPY(QGeoCodeReply)
 };
 
 QT_END_NAMESPACE
diff --git a/src/location/maps/qgeocodereply_p.h b/src/location/maps/qgeocodereply_p.h
index 6a8cd913..0f64f49c 100644
--- a/src/location/maps/qgeocodereply_p.h
+++ b/src/location/maps/qgeocodereply_p.h
@@ -63,14 +63,14 @@ QT_BEGIN_NAMESPACE
 
 class QGeoLocation;
 
-class QGeocodeReplyPrivate
+class QGeoCodeReplyPrivate
 {
 public:
-    QGeocodeReplyPrivate();
-    QGeocodeReplyPrivate(QGeocodeReply::Error error, const QString &errorString);
-    ~QGeocodeReplyPrivate();
+    QGeoCodeReplyPrivate();
+    QGeoCodeReplyPrivate(QGeoCodeReply::Error error, const QString &errorString);
+    ~QGeoCodeReplyPrivate();
 
-    QGeocodeReply::Error error;
+    QGeoCodeReply::Error error;
     QString errorString;
     bool isFinished;
 
@@ -80,7 +80,7 @@ public:
     int limit;
     int offset;
 private:
-    Q_DISABLE_COPY(QGeocodeReplyPrivate)
+    Q_DISABLE_COPY(QGeoCodeReplyPrivate)
 };
 
 QT_END_NAMESPACE
diff --git a/src/location/maps/qgeocodingmanager.cpp b/src/location/maps/qgeocodingmanager.cpp
index 37e46e86..5dcb873e 100644
--- a/src/location/maps/qgeocodingmanager.cpp
+++ b/src/location/maps/qgeocodingmanager.cpp
@@ -51,16 +51,16 @@
 QT_BEGIN_NAMESPACE
 
 /*!
-    \class QGeocodingManager
+    \class QGeoCodingManager
     \inmodule QtLocation
     \ingroup QtLocation-geocoding
     \since Qt Location 5.0
 
-    \brief The QGeocodingManager class provides support for geocoding
+    \brief The QGeoCodingManager class provides support for geocoding
     operations.
 
     The geocode() and reverseGeocode() functions return
-    QGeocodeReply objects, which manage these operations and report on the
+    QGeoCodeReply objects, which manage these operations and report on the
     result of the operations and any errors which may have occurred.
 
     The geocode() and reverseGeocode() functions can be used to convert
@@ -70,7 +70,7 @@ QT_BEGIN_NAMESPACE
     geocoding operation, if the string provided can be interpreted as
     an address it can be geocoded to coordinate information.
 
-    Instances of QGeocodingManager can be accessed with
+    Instances of QGeoCodingManager can be accessed with
     QGeoServiceProvider::geocodingManager().
 */
 
@@ -79,26 +79,26 @@ QT_BEGIN_NAMESPACE
     implementation provided by \a engine.
 
     This constructor is used interally by QGeoServiceProviderFactory. Regular
-    users should acquire instances of QGeocodingManager with
+    users should acquire instances of QGeoCodingManager with
     QGeoServiceProvider::geocodingManager();
 */
-QGeocodingManager::QGeocodingManager(QGeocodingManagerEngine *engine, QObject *parent)
+QGeoCodingManager::QGeoCodingManager(QGeoCodingManagerEngine *engine, QObject *parent)
     : QObject(parent),
-      d_ptr(new QGeocodingManagerPrivate())
+      d_ptr(new QGeoCodingManagerPrivate())
 {
     d_ptr->engine = engine;
     if (d_ptr->engine) {
         d_ptr->engine->setParent(this);
 
         connect(d_ptr->engine,
-                SIGNAL(finished(QGeocodeReply*)),
+                SIGNAL(finished(QGeoCodeReply*)),
                 this,
-                SIGNAL(finished(QGeocodeReply*)));
+                SIGNAL(finished(QGeoCodeReply*)));
 
         connect(d_ptr->engine,
-                SIGNAL(error(QGeocodeReply*, QGeocodeReply::Error, QString)),
+                SIGNAL(error(QGeoCodeReply*, QGeoCodeReply::Error, QString)),
                 this,
-                SIGNAL(error(QGeocodeReply*, QGeocodeReply::Error, QString)));
+                SIGNAL(error(QGeoCodeReply*, QGeoCodeReply::Error, QString)));
     } else {
         qFatal("The geocoding manager engine that was set for this geocoding manager was NULL.");
     }
@@ -107,7 +107,7 @@ QGeocodingManager::QGeocodingManager(QGeocodingManagerEngine *engine, QObject *p
 /*!
     Destroys this manager.
 */
-QGeocodingManager::~QGeocodingManager()
+QGeoCodingManager::~QGeoCodingManager()
 {
     delete d_ptr;
 }
@@ -119,7 +119,7 @@ QGeocodingManager::~QGeocodingManager()
     The combination of managerName() and managerVersion() should be unique
     amongst the plugin implementations.
 */
-QString QGeocodingManager::managerName() const
+QString QGeoCodingManager::managerName() const
 {
 //    if (!d_ptr->engine)
 //        return QString();
@@ -134,7 +134,7 @@ QString QGeocodingManager::managerName() const
     The combination of managerName() and managerVersion() should be unique
     amongst the plugin implementations.
 */
-int QGeocodingManager::managerVersion() const
+int QGeoCodingManager::managerVersion() const
 {
 //    if (!d_ptr->engine)
 //        return -1;
@@ -146,16 +146,16 @@ int QGeocodingManager::managerVersion() const
     Begins the geocoding of \a address. Geocoding is the process of finding a
     coordinate that corresponds to a given address.
 
-    A QGeocodeReply object will be returned, which can be used to manage the
+    A QGeoCodeReply object will be returned, which can be used to manage the
     geocoding operation and to return the results of the operation.
 
-    This manager and the returned QGeocodeReply object will emit signals
+    This manager and the returned QGeoCodeReply object will emit signals
     indicating if the operation completes or if errors occur.
 
     If supportsGeocoding() returns false an
-    QGeocodeReply::UnsupportedOptionError will occur.
+    QGeoCodeReply::UnsupportedOptionError will occur.
 
-    Once the operation has completed, QGeocodeReply::locations() can be used to
+    Once the operation has completed, QGeoCodeReply::locations() can be used to
     retrieve the results, which will consist of a list of QGeoLocation objects.
     These objects represent a combination of coordinate and address data.
 
@@ -169,14 +169,14 @@ int QGeocodingManager::managerVersion() const
     service will attempt to geocode all matches for the specified data.
 
     The user is responsible for deleting the returned reply object, although
-    this can be done in the slot connected to QGeocodingManager::finished(),
-    QGeocodingManager::error(), QGeocodeReply::finished() or
-    QGeocodeReply::error() with deleteLater().
+    this can be done in the slot connected to QGeoCodingManager::finished(),
+    QGeoCodingManager::error(), QGeoCodeReply::finished() or
+    QGeoCodeReply::error() with deleteLater().
 */
-QGeocodeReply *QGeocodingManager::geocode(const QGeoAddress &address, const QGeoShape &bounds)
+QGeoCodeReply *QGeoCodingManager::geocode(const QGeoAddress &address, const QGeoShape &bounds)
 {
 //    if (!d_ptr->engine)
-//        return new QGeocodeReply(QGeocodeReply::EngineNotSetError, "The geocoding manager was not created with a valid engine.", this);
+//        return new QGeoCodeReply(QGeoCodeReply::EngineNotSetError, "The geocoding manager was not created with a valid engine.", this);
 
     return d_ptr->engine->geocode(address, bounds);
 }
@@ -186,16 +186,16 @@ QGeocodeReply *QGeocodingManager::geocode(const QGeoAddress &address, const QGeo
     Begins the reverse geocoding of \a coordinate. Reverse geocoding is the
     process of finding an address that corresponds to a given coordinate.
 
-    A QGeocodeReply object will be returned, which can be used to manage the
+    A QGeoCodeReply object will be returned, which can be used to manage the
     reverse geocoding operation and to return the results of the operation.
 
-    This manager and the returned QGeocodeReply object will emit signals
+    This manager and the returned QGeoCodeReply object will emit signals
     indicating if the operation completes or if errors occur.
 
     If supportsReverseGeocoding() returns false an
-    QGeocodeReply::UnsupportedOptionError will occur.
+    QGeoCodeReply::UnsupportedOptionError will occur.
 
-    At that point QGeocodeReply::locations() can be used to retrieve the
+    At that point QGeoCodeReply::locations() can be used to retrieve the
     results, which will consist of a list of QGeoLocation objects. These objects
     represent a combination of coordinate and address data.
 
@@ -214,14 +214,14 @@ QGeocodeReply *QGeocodingManager::geocode(const QGeoAddress &address, const QGeo
     limit the results to those that are contained within \a bounds.
 
     The user is responsible for deleting the returned reply object, although
-    this can be done in the slot connected to QGeocodingManager::finished(),
-    QGeocodingManager::error(), QGeocodeReply::finished() or
-    QGeocodeReply::error() with deleteLater().
+    this can be done in the slot connected to QGeoCodingManager::finished(),
+    QGeoCodingManager::error(), QGeoCodeReply::finished() or
+    QGeoCodeReply::error() with deleteLater().
 */
-QGeocodeReply *QGeocodingManager::reverseGeocode(const QGeoCoordinate &coordinate, const QGeoShape &bounds)
+QGeoCodeReply *QGeoCodingManager::reverseGeocode(const QGeoCoordinate &coordinate, const QGeoShape &bounds)
 {
 //    if (!d_ptr->engine)
-//        return new QGeocodeReply(QGeocodeReply::EngineNotSetError, "The geocoding manager was not created with a valid engine.", this);
+//        return new QGeoCodeReply(QGeoCodeReply::EngineNotSetError, "The geocoding manager was not created with a valid engine.", this);
 
     return d_ptr->engine->reverseGeocode(coordinate, bounds);
 }
@@ -229,13 +229,13 @@ QGeocodeReply *QGeocodingManager::reverseGeocode(const QGeoCoordinate &coordinat
 /*!
     Begins geocoding for a location matching \a address.
 
-    A QGeocodeReply object will be returned, which can be used to manage the
+    A QGeoCodeReply object will be returned, which can be used to manage the
     geocoding operation and to return the results of the operation.
 
-    This manager and the returned QGeocodeReply object will emit signals
+    This manager and the returned QGeoCodeReply object will emit signals
     indicating if the operation completes or if errors occur.
 
-    Once the operation has completed, QGeocodeReply::locations() can be used to
+    Once the operation has completed, QGeoCodeReply::locations() can be used to
     retrieve the results, which will consist of a list of QGeoLocation objects.
     These objects represent a combination of coordinate and address data.
 
@@ -251,19 +251,19 @@ QGeocodeReply *QGeocodingManager::reverseGeocode(const QGeoCoordinate &coordinat
     limit the results to those that are contained within \a bounds.
 
     The user is responsible for deleting the returned reply object, although
-    this can be done in the slot connected to QGeocodingManager::finished(),
-    QGeocodingManager::error(), QGeocodeReply::finished() or
-    QGeocodeReply::error() with deleteLater().
+    this can be done in the slot connected to QGeoCodingManager::finished(),
+    QGeoCodingManager::error(), QGeoCodeReply::finished() or
+    QGeoCodeReply::error() with deleteLater().
 */
-QGeocodeReply *QGeocodingManager::geocode(const QString &address,
+QGeoCodeReply *QGeoCodingManager::geocode(const QString &address,
         int limit,
         int offset,
         const QGeoShape &bounds)
 {
 //    if (!d_ptr->engine)
-//        return new QGeocodeReply(QGeocodeReply::EngineNotSetError, "The geocoding manager was not created with a valid engine.", this);
+//        return new QGeoCodeReply(QGeoCodeReply::EngineNotSetError, "The geocoding manager was not created with a valid engine.", this);
 
-    QGeocodeReply *reply = d_ptr->engine->geocode(address,
+    QGeoCodeReply *reply = d_ptr->engine->geocode(address,
                              limit,
                              offset,
                              bounds);
@@ -278,7 +278,7 @@ QGeocodeReply *QGeocodingManager::geocode(const QString &address,
 
     The locale used defaults to the system locale if this is not set.
 */
-void QGeocodingManager::setLocale(const QLocale &locale)
+void QGeoCodingManager::setLocale(const QLocale &locale)
 {
     d_ptr->engine->setLocale(locale);
 }
@@ -287,20 +287,20 @@ void QGeocodingManager::setLocale(const QLocale &locale)
     Returns the locale used to hint to this geocoding manager about what
     language to use for the results.
 */
-QLocale QGeocodingManager::locale() const
+QLocale QGeoCodingManager::locale() const
 {
     return d_ptr->engine->locale();
 }
 
 /*!
-\fn void QGeocodingManager::finished(QGeocodeReply *reply)
+\fn void QGeoCodingManager::finished(QGeoCodeReply *reply)
 
     This signal is emitted when \a reply has finished processing.
 
-    If reply::error() equals QGeocodeReply::NoError then the processing
+    If reply::error() equals QGeoCodeReply::NoError then the processing
     finished successfully.
 
-    This signal and QGeocodeReply::finished() will be emitted at the same
+    This signal and QGeoCodeReply::finished() will be emitted at the same
     time.
 
     \note Do not delete the \a reply object in the slot connected to this
@@ -308,15 +308,15 @@ QLocale QGeocodingManager::locale() const
 */
 
 /*!
-\fn void QGeocodingManager::error(QGeocodeReply *reply, QGeocodeReply::Error error, QString errorString)
+\fn void QGeoCodingManager::error(QGeoCodeReply *reply, QGeoCodeReply::Error error, QString errorString)
 
     This signal is emitted when an error has been detected in the processing of
-    \a reply. The QGeocodingManager::finished() signal will probably follow.
+    \a reply. The QGeoCodingManager::finished() signal will probably follow.
 
     The error will be described by the error code \a error. If \a errorString is
     not empty it will contain a textual description of the error.
 
-    This signal and QGeocodeReply::error() will be emitted at the same time.
+    This signal and QGeoCodeReply::error() will be emitted at the same time.
 
     \note Do not delete the \a reply object in the slot connected to this
     signal. Use deleteLater() instead.
@@ -325,10 +325,10 @@ QLocale QGeocodingManager::locale() const
 /*******************************************************************************
 *******************************************************************************/
 
-QGeocodingManagerPrivate::QGeocodingManagerPrivate()
+QGeoCodingManagerPrivate::QGeoCodingManagerPrivate()
     : engine(0) {}
 
-QGeocodingManagerPrivate::~QGeocodingManagerPrivate()
+QGeoCodingManagerPrivate::~QGeoCodingManagerPrivate()
 {
     delete engine;
 }
diff --git a/src/location/maps/qgeocodingmanager.h b/src/location/maps/qgeocodingmanager.h
index 6604c25d..6f55fcf5 100644
--- a/src/location/maps/qgeocodingmanager.h
+++ b/src/location/maps/qgeocodingmanager.h
@@ -42,7 +42,7 @@
 #ifndef QGEOCODINGMANAGER_H
 #define QGEOCODINGMANAGER_H
 
-#include <QtLocation/QGeocodeReply>
+#include <QtLocation/QGeoCodeReply>
 #include <QtPositioning/QGeoRectangle>
 
 #include <QObject>
@@ -53,40 +53,40 @@ QT_BEGIN_NAMESPACE
 
 class QLocale;
 
-class QGeocodingManagerEngine;
-class QGeocodingManagerPrivate;
+class QGeoCodingManagerEngine;
+class QGeoCodingManagerPrivate;
 
-class Q_LOCATION_EXPORT QGeocodingManager : public QObject
+class Q_LOCATION_EXPORT QGeoCodingManager : public QObject
 {
     Q_OBJECT
 public:
-    ~QGeocodingManager();
+    ~QGeoCodingManager();
 
     QString managerName() const;
     int managerVersion() const;
 
-    QGeocodeReply *geocode(const QGeoAddress &address,
+    QGeoCodeReply *geocode(const QGeoAddress &address,
                            const QGeoShape &bounds = QGeoShape());
-    QGeocodeReply *geocode(const QString &searchString,
+    QGeoCodeReply *geocode(const QString &searchString,
                             int limit = -1,
                             int offset = 0,
                            const QGeoShape &bounds = QGeoShape());
 
-    QGeocodeReply *reverseGeocode(const QGeoCoordinate &coordinate,
+    QGeoCodeReply *reverseGeocode(const QGeoCoordinate &coordinate,
                                   const QGeoShape &bounds = QGeoShape());
 
     void setLocale(const QLocale &locale);
     QLocale locale() const;
 
 Q_SIGNALS:
-    void finished(QGeocodeReply *reply);
-    void error(QGeocodeReply *reply, QGeocodeReply::Error error, QString errorString = QString());
+    void finished(QGeoCodeReply *reply);
+    void error(QGeoCodeReply *reply, QGeoCodeReply::Error error, QString errorString = QString());
 
 private:
-    QGeocodingManager(QGeocodingManagerEngine *engine, QObject *parent = 0);
+    QGeoCodingManager(QGeoCodingManagerEngine *engine, QObject *parent = 0);
 
-    QGeocodingManagerPrivate *d_ptr;
-    Q_DISABLE_COPY(QGeocodingManager)
+    QGeoCodingManagerPrivate *d_ptr;
+    Q_DISABLE_COPY(QGeoCodingManager)
 
     friend class QGeoServiceProvider;
     friend class QGeoServiceProviderPrivate;
diff --git a/src/location/maps/qgeocodingmanager_p.h b/src/location/maps/qgeocodingmanager_p.h
index 89964542..8c28162f 100644
--- a/src/location/maps/qgeocodingmanager_p.h
+++ b/src/location/maps/qgeocodingmanager_p.h
@@ -61,18 +61,18 @@
 
 QT_BEGIN_NAMESPACE
 
-class QGeocodingManagerEngine;
+class QGeoCodingManagerEngine;
 
-class QGeocodingManagerPrivate
+class QGeoCodingManagerPrivate
 {
 public:
-    QGeocodingManagerPrivate();
-    ~QGeocodingManagerPrivate();
+    QGeoCodingManagerPrivate();
+    ~QGeoCodingManagerPrivate();
 
-    QGeocodingManagerEngine *engine;
+    QGeoCodingManagerEngine *engine;
 
 private:
-    Q_DISABLE_COPY(QGeocodingManagerPrivate)
+    Q_DISABLE_COPY(QGeoCodingManagerPrivate)
 };
 
 QT_END_NAMESPACE
diff --git a/src/location/maps/qgeocodingmanagerengine.cpp b/src/location/maps/qgeocodingmanagerengine.cpp
index 3ba59f68..f3aa2870 100644
--- a/src/location/maps/qgeocodingmanagerengine.cpp
+++ b/src/location/maps/qgeocodingmanagerengine.cpp
@@ -50,18 +50,18 @@
 QT_BEGIN_NAMESPACE
 
 /*!
-    \class QGeocodingManagerEngine
+    \class QGeoCodingManagerEngine
     \inmodule QtLocation
     \ingroup QtLocation-impl
     \since Qt Location 5.0
 
-    \brief The QGeocodingManagerEngine class provides an interface and
+    \brief The QGeoCodingManagerEngine class provides an interface and
     convenience methods to implementers of QGeoServiceProvider plugins who want
     to provide support for geocoding operations.
 
     In the default implementation, supportsGeocoding() and supportsReverseGeocoding() returns false while
     geocode() and reverseGeocode()
-    cause QGeocodeReply::UnsupportedOptionError to occur.
+    cause QGeoCodeReply::UnsupportedOptionError to occur.
 
     If the service provider supports geocoding the subclass should provide an
     implementation of geocode() and call setSupportsGeocoding(true) at
@@ -72,21 +72,21 @@ QT_BEGIN_NAMESPACE
     setSupportsReverseGeocoding(true) at some point in time before
     reverseGeocode() is called.
 
-    A subclass of QGeocodingManagerEngine will often make use of a subclass
-    fo QGeocodeReply internally, in order to add any engine-specific
+    A subclass of QGeoCodingManagerEngine will often make use of a subclass
+    fo QGeoCodeReply internally, in order to add any engine-specific
     data (such as a QNetworkReply object for network-based services) to the
-    QGeocodeReply instances used by the engine.
+    QGeoCodeReply instances used by the engine.
 
-    \sa QGeocodingManager
+    \sa QGeoCodingManager
 */
 
 /*!
     Constructs a new engine with the specified \a parent, using \a parameters
     to pass any implementation specific data to the engine.
 */
-QGeocodingManagerEngine::QGeocodingManagerEngine(const QMap<QString, QVariant> &parameters, QObject *parent)
+QGeoCodingManagerEngine::QGeoCodingManagerEngine(const QMap<QString, QVariant> &parameters, QObject *parent)
     : QObject(parent),
-      d_ptr(new QGeocodingManagerEnginePrivate())
+      d_ptr(new QGeoCodingManagerEnginePrivate())
 {
     Q_UNUSED(parameters)
 }
@@ -94,7 +94,7 @@ QGeocodingManagerEngine::QGeocodingManagerEngine(const QMap<QString, QVariant> &
 /*!
     Destroys this engine.
 */
-QGeocodingManagerEngine::~QGeocodingManagerEngine()
+QGeoCodingManagerEngine::~QGeoCodingManagerEngine()
 {
     delete d_ptr;
 }
@@ -106,7 +106,7 @@ QGeocodingManagerEngine::~QGeocodingManagerEngine()
     The combination of managerName() and managerVersion() should be unique
     amongst plugin implementations.
 */
-void QGeocodingManagerEngine::setManagerName(const QString &managerName)
+void QGeoCodingManagerEngine::setManagerName(const QString &managerName)
 {
     d_ptr->managerName = managerName;
 }
@@ -118,7 +118,7 @@ void QGeocodingManagerEngine::setManagerName(const QString &managerName)
     The combination of managerName() and managerVersion() should be unique
     amongst plugin implementations.
 */
-QString QGeocodingManagerEngine::managerName() const
+QString QGeoCodingManagerEngine::managerName() const
 {
     return d_ptr->managerName;
 }
@@ -129,7 +129,7 @@ QString QGeocodingManagerEngine::managerName() const
     The combination of managerName() and managerVersion() should be unique
     amongst plugin implementations.
 */
-void QGeocodingManagerEngine::setManagerVersion(int managerVersion)
+void QGeoCodingManagerEngine::setManagerVersion(int managerVersion)
 {
     d_ptr->managerVersion = managerVersion;
 }
@@ -140,7 +140,7 @@ void QGeocodingManagerEngine::setManagerVersion(int managerVersion)
     The combination of managerName() and managerVersion() should be unique
     amongst plugin implementations.
 */
-int QGeocodingManagerEngine::managerVersion() const
+int QGeoCodingManagerEngine::managerVersion() const
 {
     return d_ptr->managerVersion;
 }
@@ -149,16 +149,16 @@ int QGeocodingManagerEngine::managerVersion() const
     Begins the geocoding of \a address. Geocoding is the process of finding a
     coordinate that corresponds to a given address.
 
-    A QGeocodeReply object will be returned, which can be used to manage the
+    A QGeoCodeReply object will be returned, which can be used to manage the
     geocoding operation and to return the results of the operation.
 
-    This engine and the returned QGeocodeReply object will emit signals
+    This engine and the returned QGeoCodeReply object will emit signals
     indicating if the operation completes or if errors occur.
 
     If supportsGeocoding() returns false an
-    QGeocodeReply::UnsupportedOptionError will occur.
+    QGeoCodeReply::UnsupportedOptionError will occur.
 
-    Once the operation has completed, QGeocodeReply::locations() can be used to
+    Once the operation has completed, QGeoCodeReply::locations() can be used to
     retrieve the results, which will consist of a list of QGeoLocation objects.
     These objects represent a combination of coordinate and address data.
 
@@ -172,16 +172,16 @@ int QGeocodingManagerEngine::managerVersion() const
     service will attempt to geocode all matches for the specified data.
 
     The user is responsible for deleting the returned reply object, although
-    this can be done in the slot connected to QGeocodingManagerEngine::finished(),
-    QGeocodingManagerEngine::error(), QGeocodeReply::finished() or
-    QGeocodeReply::error() with deleteLater().
+    this can be done in the slot connected to QGeoCodingManagerEngine::finished(),
+    QGeoCodingManagerEngine::error(), QGeoCodeReply::finished() or
+    QGeoCodeReply::error() with deleteLater().
 */
-QGeocodeReply *QGeocodingManagerEngine::geocode(const QGeoAddress &address,
+QGeoCodeReply *QGeoCodingManagerEngine::geocode(const QGeoAddress &address,
         const QGeoShape &bounds)
 {
     Q_UNUSED(address)
     Q_UNUSED(bounds)
-    return new QGeocodeReply(QGeocodeReply::UnsupportedOptionError,
+    return new QGeoCodeReply(QGeoCodeReply::UnsupportedOptionError,
                                QLatin1String("Geocoding is not supported by this service provider."), this);
 }
 
@@ -189,16 +189,16 @@ QGeocodeReply *QGeocodingManagerEngine::geocode(const QGeoAddress &address,
     Begins the reverse geocoding of \a coordinate. Reverse geocoding is the
     process of finding an address that corresponds to a given coordinate.
 
-    A QGeocodeReply object will be returned, which can be used to manage the
+    A QGeoCodeReply object will be returned, which can be used to manage the
     reverse geocoding operation and to return the results of the operation.
 
-    This engine and the returned QGeocodeReply object will emit signals
+    This engine and the returned QGeoCodeReply object will emit signals
     indicating if the operation completes or if errors occur.
 
     If supportsReverseGeocoding() returns false an
-    QGeocodeReply::UnsupportedOptionError will occur.
+    QGeoCodeReply::UnsupportedOptionError will occur.
 
-    At that point QGeocodeReply::locations() can be used to retrieve the
+    At that point QGeoCodeReply::locations() can be used to retrieve the
     results, which will consist of a list of QGeoLocation objects. These objects
     represent a combination of coordinate and address data.
 
@@ -217,29 +217,29 @@ QGeocodeReply *QGeocodingManagerEngine::geocode(const QGeoAddress &address,
     limit the results to those that are contained by \a bounds.
 
     The user is responsible for deleting the returned reply object, although
-    this can be done in the slot connected to QGeocodingManagerEngine::finished(),
-    QGeocodingManagerEngine::error(), QGeocodeReply::finished() or
-    QGeocodeReply::error() with deleteLater().
+    this can be done in the slot connected to QGeoCodingManagerEngine::finished(),
+    QGeoCodingManagerEngine::error(), QGeoCodeReply::finished() or
+    QGeoCodeReply::error() with deleteLater().
 */
-QGeocodeReply *QGeocodingManagerEngine::reverseGeocode(const QGeoCoordinate &coordinate,
-        const QGeoShape &bounds)
+QGeoCodeReply *QGeoCodingManagerEngine::reverseGeocode(const QGeoCoordinate &coordinate,
+                                                       const QGeoShape &bounds)
 {
     Q_UNUSED(coordinate)
     Q_UNUSED(bounds)
-    return new QGeocodeReply(QGeocodeReply::UnsupportedOptionError,
+    return new QGeoCodeReply(QGeoCodeReply::UnsupportedOptionError,
                                QLatin1String("Reverse geocoding is not supported by this service provider."), this);
 }
 
 /*!
     Begins geocoding for a location matching \a address.
 
-    A QGeocodeReply object will be returned, which can be used to manage the
+    A QGeoCodeReply object will be returned, which can be used to manage the
     geocoding operation and to return the results of the operation.
 
-    This engine and the returned QGeocodeReply object will emit signals
+    This engine and the returned QGeoCodeReply object will emit signals
     indicating if the operation completes or if errors occur.
 
-    Once the operation has completed, QGeocodeReply::locations() can be used to
+    Once the operation has completed, QGeoCodeReply::locations() can be used to
     retrieve the results, which will consist of a list of QGeoLocation objects.
     These objects represent a combination of coordinate and address data.
 
@@ -255,22 +255,22 @@ QGeocodeReply *QGeocodingManagerEngine::reverseGeocode(const QGeoCoordinate &coo
     limit the results to those that are contained by \a bounds.
 
     The user is responsible for deleting the returned reply object, although
-    this can be done in the slot connected to QGeocodingManagerEngine::finished(),
-    QGeocodingManagerEngine::error(), QGeocodeReply::finished() or
-    QGeocodeReply::error() with deleteLater().
+    this can be done in the slot connected to QGeoCodingManagerEngine::finished(),
+    QGeoCodingManagerEngine::error(), QGeoCodeReply::finished() or
+    QGeoCodeReply::error() with deleteLater().
 */
-QGeocodeReply *QGeocodingManagerEngine::geocode(const QString &address,
-        int limit,
-        int offset,
-        const QGeoShape &bounds)
+QGeoCodeReply *QGeoCodingManagerEngine::geocode(const QString &address,
+                                                int limit,
+                                                int offset,
+                                                const QGeoShape &bounds)
 {
     Q_UNUSED(address)
     Q_UNUSED(limit)
     Q_UNUSED(offset)
     Q_UNUSED(bounds)
 
-    return new QGeocodeReply(QGeocodeReply::UnsupportedOptionError,
-                               QLatin1String("Searching is not supported by this service provider."), this);
+    return new QGeoCodeReply(QGeoCodeReply::UnsupportedOptionError,
+                             QLatin1String("Searching is not supported by this service provider."), this);
 }
 
 /*!
@@ -281,7 +281,7 @@ QGeocodeReply *QGeocodingManagerEngine::geocode(const QString &address,
 
     The locale used defaults to the system locale if this is not set.
 */
-void QGeocodingManagerEngine::setLocale(const QLocale &locale)
+void QGeoCodingManagerEngine::setLocale(const QLocale &locale)
 {
     d_ptr->locale = locale;
 }
@@ -290,20 +290,20 @@ void QGeocodingManagerEngine::setLocale(const QLocale &locale)
     Returns the locale used to hint to this geocoding manager about what
     language to use for the results.
 */
-QLocale QGeocodingManagerEngine::locale() const
+QLocale QGeoCodingManagerEngine::locale() const
 {
     return d_ptr->locale;
 }
 
 /*!
-\fn void QGeocodingManagerEngine::finished(QGeocodeReply *reply)
+\fn void QGeoCodingManagerEngine::finished(QGeoCodeReply *reply)
 
     This signal is emitted when \a reply has finished processing.
 
-    If reply::error() equals QGeocodeReply::NoError then the processing
+    If reply::error() equals QGeoCodeReply::NoError then the processing
     finished successfully.
 
-    This signal and QGeocodeReply::finished() will be emitted at the same
+    This signal and QGeoCodeReply::finished() will be emitted at the same
     time.
 
     \note Do not delete the \a reply object in the slot connected to this
@@ -311,15 +311,15 @@ QLocale QGeocodingManagerEngine::locale() const
 */
 
 /*!
-\fn void QGeocodingManagerEngine::error(QGeocodeReply *reply, QGeocodeReply::Error error, QString errorString)
+\fn void QGeoCodingManagerEngine::error(QGeoCodeReply *reply, QGeoCodeReply::Error error, QString errorString)
 
     This signal is emitted when an error has been detected in the processing of
-    \a reply. The QGeocodingManagerEngine::finished() signal will probably follow.
+    \a reply. The QGeoCodingManagerEngine::finished() signal will probably follow.
 
     The error will be described by the error code \a error. If \a errorString is
     not empty it will contain a textual description of the error.
 
-    This signal and QGeocodeReply::error() will be emitted at the same time.
+    This signal and QGeoCodeReply::error() will be emitted at the same time.
 
     \note Do not delete the \a reply object in the slot connected to this
     signal. Use deleteLater() instead.
@@ -328,11 +328,11 @@ QLocale QGeocodingManagerEngine::locale() const
 /*******************************************************************************
 *******************************************************************************/
 
-QGeocodingManagerEnginePrivate::QGeocodingManagerEnginePrivate()
+QGeoCodingManagerEnginePrivate::QGeoCodingManagerEnginePrivate()
     : managerVersion(-1)
 {}
 
-QGeocodingManagerEnginePrivate::~QGeocodingManagerEnginePrivate()
+QGeoCodingManagerEnginePrivate::~QGeoCodingManagerEnginePrivate()
 {
 }
 
diff --git a/src/location/maps/qgeocodingmanagerengine.h b/src/location/maps/qgeocodingmanagerengine.h
index 5b727b48..aa2839a0 100644
--- a/src/location/maps/qgeocodingmanagerengine.h
+++ b/src/location/maps/qgeocodingmanagerengine.h
@@ -44,30 +44,30 @@
 
 #include <QtCore/QObject>
 #include <QtLocation/qlocationglobal.h>
-#include <QtLocation/QGeocodeReply>
+#include <QtLocation/QGeoCodeReply>
 
 QT_BEGIN_NAMESPACE
 
 class QGeoAddress;
 class QGeoShape;
-class QGeocodingManagerEnginePrivate;
+class QGeoCodingManagerEnginePrivate;
 
-class Q_LOCATION_EXPORT QGeocodingManagerEngine : public QObject
+class Q_LOCATION_EXPORT QGeoCodingManagerEngine : public QObject
 {
     Q_OBJECT
 public:
-    QGeocodingManagerEngine(const QMap<QString, QVariant> &parameters, QObject *parent = 0);
-    virtual ~QGeocodingManagerEngine();
+    QGeoCodingManagerEngine(const QMap<QString, QVariant> &parameters, QObject *parent = 0);
+    virtual ~QGeoCodingManagerEngine();
 
     QString managerName() const;
     int managerVersion() const;
 
-    virtual QGeocodeReply *geocode(const QGeoAddress &address, const QGeoShape &bounds);
-    virtual QGeocodeReply *geocode(const QString &address,
+    virtual QGeoCodeReply *geocode(const QGeoAddress &address, const QGeoShape &bounds);
+    virtual QGeoCodeReply *geocode(const QString &address,
                                    int limit,
                                    int offset,
                                    const QGeoShape &bounds);
-    virtual QGeocodeReply *reverseGeocode(const QGeoCoordinate &coordinate,
+    virtual QGeoCodeReply *reverseGeocode(const QGeoCoordinate &coordinate,
                                           const QGeoShape &bounds);
 
 
@@ -75,15 +75,15 @@ public:
     QLocale locale() const;
 
 Q_SIGNALS:
-    void finished(QGeocodeReply *reply);
-    void error(QGeocodeReply *reply, QGeocodeReply::Error error, QString errorString = QString());
+    void finished(QGeoCodeReply *reply);
+    void error(QGeoCodeReply *reply, QGeoCodeReply::Error error, QString errorString = QString());
 
 private:
     void setManagerName(const QString &managerName);
     void setManagerVersion(int managerVersion);
 
-    QGeocodingManagerEnginePrivate *d_ptr;
-    Q_DISABLE_COPY(QGeocodingManagerEngine)
+    QGeoCodingManagerEnginePrivate *d_ptr;
+    Q_DISABLE_COPY(QGeoCodingManagerEngine)
 
     friend class QGeoServiceProvider;
     friend class QGeoServiceProviderPrivate;
diff --git a/src/location/maps/qgeocodingmanagerengine_p.h b/src/location/maps/qgeocodingmanagerengine_p.h
index 40e727c4..c17272c6 100644
--- a/src/location/maps/qgeocodingmanagerengine_p.h
+++ b/src/location/maps/qgeocodingmanagerengine_p.h
@@ -60,11 +60,11 @@
 
 QT_BEGIN_NAMESPACE
 
-class QGeocodingManagerEnginePrivate
+class QGeoCodingManagerEnginePrivate
 {
 public:
-    QGeocodingManagerEnginePrivate();
-    ~QGeocodingManagerEnginePrivate();
+    QGeoCodingManagerEnginePrivate();
+    ~QGeoCodingManagerEnginePrivate();
 
     QString managerName;
     int managerVersion;
@@ -72,7 +72,7 @@ public:
     QLocale locale;
 
 private:
-    Q_DISABLE_COPY(QGeocodingManagerEnginePrivate)
+    Q_DISABLE_COPY(QGeoCodingManagerEnginePrivate)
 };
 
 QT_END_NAMESPACE
diff --git a/src/location/maps/qgeoserviceprovider.cpp b/src/location/maps/qgeoserviceprovider.cpp
index dcfe326c..c91ef8a5 100644
--- a/src/location/maps/qgeoserviceprovider.cpp
+++ b/src/location/maps/qgeoserviceprovider.cpp
@@ -312,7 +312,7 @@ Engine *createEngine(QGeoServiceProviderPrivate *d_ptr)
 {
     return 0;
 }
-template <> QGeocodingManagerEngine *createEngine<QGeocodingManagerEngine>(QGeoServiceProviderPrivate *d_ptr)
+template <> QGeoCodingManagerEngine *createEngine<QGeoCodingManagerEngine>(QGeoServiceProviderPrivate *d_ptr)
 {
     return d_ptr->factory->createGeocodingManagerEngine(d_ptr->parameterMap, &(d_ptr->geocodeError), &(d_ptr->geocodeErrorString));
 }
@@ -382,29 +382,29 @@ Manager *QGeoServiceProviderPrivate::manager(QGeoServiceProvider::Error *_error,
 }
 
 /*!
-    Returns the QGeocodingManager made available by the service
+    Returns the QGeoCodingManager made available by the service
     provider.
 
     This function will return 0 if the service provider does not provide
     any geocoding services.
 
-    This function will attempt to construct a QGeocodingManager instance
+    This function will attempt to construct a QGeoCodingManager instance
     when it is called for the first time.  If the attempt is successful the
-    QGeocodingManager will be cached, otherwise each call of this function
-    will attempt to construct a QGeocodingManager instance until the
+    QGeoCodingManager will be cached, otherwise each call of this function
+    will attempt to construct a QGeoCodingManager instance until the
     construction is successful.
 
-    The QGeocodingManager is owned by this QGeoServiceProvider and should not
+    The QGeoCodingManager is owned by this QGeoServiceProvider and should not
     be deleted separately. Users should assume that deleting the
     QGeoServiceProvider renders the pointer returned by this method invalid.
 
     After this function has been called, error() and errorString() will
     report any errors which occurred during the construction of the
-    QGeocodingManager.
+    QGeoCodingManager.
 */
-QGeocodingManager *QGeoServiceProvider::geocodingManager() const
+QGeoCodingManager *QGeoServiceProvider::geocodingManager() const
 {
-    return d_ptr->manager<QGeocodingManager, QGeocodingManagerEngine>(
+    return d_ptr->manager<QGeoCodingManager, QGeoCodingManagerEngine>(
                &(d_ptr->geocodeError), &(d_ptr->geocodeErrorString),
                &(d_ptr->geocodingManager));
 }
diff --git a/src/location/maps/qgeoserviceprovider.h b/src/location/maps/qgeoserviceprovider.h
index 155aa196..b720b86a 100644
--- a/src/location/maps/qgeoserviceprovider.h
+++ b/src/location/maps/qgeoserviceprovider.h
@@ -51,11 +51,11 @@ QT_BEGIN_NAMESPACE
 
 class QLocale;
 class QStringList;
-class QGeocodingManager;
+class QGeoCodingManager;
 class QGeoMappingManager;
 class QGeoRoutingManager;
 class QPlaceManager;
-class QGeocodingManagerEngine;
+class QGeoCodingManagerEngine;
 class QGeoMappingManagerEngine;
 class QGeoRoutingManagerEngine;
 class QPlaceManagerEngine;
@@ -142,7 +142,7 @@ public:
     MappingFeatures mappingFeatures() const;
     PlacesFeatures placesFeatures() const;
 
-    QGeocodingManager *geocodingManager() const;
+    QGeoCodingManager *geocodingManager() const;
     QGeoMappingManager *mappingManager() const;
     QGeoRoutingManager *routingManager() const;
     QPlaceManager *placeManager() const;
diff --git a/src/location/maps/qgeoserviceprovider_p.h b/src/location/maps/qgeoserviceprovider_p.h
index 36a56f78..1ec19c89 100644
--- a/src/location/maps/qgeoserviceprovider_p.h
+++ b/src/location/maps/qgeoserviceprovider_p.h
@@ -62,7 +62,7 @@
 
 QT_BEGIN_NAMESPACE
 
-class QGeocodingManager;
+class QGeoCodingManager;
 class QGeoRoutingManager;
 class QGeoMappingManager;
 
@@ -92,7 +92,7 @@ public:
 
     bool experimental;
 
-    QGeocodingManager *geocodingManager;
+    QGeoCodingManager *geocodingManager;
     QGeoRoutingManager *routingManager;
     QGeoMappingManager *mappingManager;
     QPlaceManager *placeManager;
diff --git a/src/location/maps/qgeoserviceproviderfactory.cpp b/src/location/maps/qgeoserviceproviderfactory.cpp
index e12e3515..8fbfb3d7 100644
--- a/src/location/maps/qgeoserviceproviderfactory.cpp
+++ b/src/location/maps/qgeoserviceproviderfactory.cpp
@@ -66,7 +66,7 @@ Destroys this QGeoServiceProviderFactory instance.
 */
 
 /*!
-    Returns a new QGeocodingManagerEngine instance, initialized with \a
+    Returns a new QGeoCodingManagerEngine instance, initialized with \a
     parameters, which implements the location geocoding functionality.
 
     If \a error is not 0 it should be set to QGeoServiceProvider::NoError on
@@ -78,9 +78,9 @@ Destroys this QGeoServiceProviderFactory instance.
     The default implementation returns 0, which causes a
     QGeoServiceProvider::NotSupportedError in QGeoServiceProvider.
 */
-QGeocodingManagerEngine *QGeoServiceProviderFactory::createGeocodingManagerEngine(const QMap<QString, QVariant> &parameters,
-        QGeoServiceProvider::Error *error,
-        QString *errorString) const
+QGeoCodingManagerEngine *QGeoServiceProviderFactory::createGeocodingManagerEngine(const QMap<QString, QVariant> &parameters,
+                                                                                  QGeoServiceProvider::Error *error,
+                                                                                  QString *errorString) const
 {
     Q_UNUSED(parameters)
     Q_UNUSED(error)
@@ -105,8 +105,8 @@ QGeocodingManagerEngine *QGeoServiceProviderFactory::createGeocodingManagerEngin
     \internal
 */
 QGeoMappingManagerEngine *QGeoServiceProviderFactory::createMappingManagerEngine(const QMap<QString, QVariant> &parameters,
-        QGeoServiceProvider::Error *error,
-        QString *errorString) const
+                                                                                 QGeoServiceProvider::Error *error,
+                                                                                 QString *errorString) const
 {
     Q_UNUSED(parameters)
     Q_UNUSED(error)
@@ -129,8 +129,8 @@ QGeoMappingManagerEngine *QGeoServiceProviderFactory::createMappingManagerEngine
     QGeoServiceProvider::NotSupportedError in QGeoServiceProvider.
 */
 QGeoRoutingManagerEngine *QGeoServiceProviderFactory::createRoutingManagerEngine(const QMap<QString, QVariant> &parameters,
-        QGeoServiceProvider::Error *error,
-        QString *errorString) const
+                                                                                 QGeoServiceProvider::Error *error,
+                                                                                 QString *errorString) const
 
 {
     Q_UNUSED(parameters)
@@ -154,8 +154,8 @@ QGeoRoutingManagerEngine *QGeoServiceProviderFactory::createRoutingManagerEngine
     QGeoServiceProvider::NotSupportedError in QGeoServiceProvider.
 */
 QPlaceManagerEngine *QGeoServiceProviderFactory::createPlaceManagerEngine(const QMap<QString, QVariant> &parameters,
-        QGeoServiceProvider::Error *error,
-        QString *errorString) const
+                                                                          QGeoServiceProvider::Error *error,
+                                                                          QString *errorString) const
 
 {
     Q_UNUSED(parameters)
diff --git a/src/location/maps/qgeoserviceproviderfactory.h b/src/location/maps/qgeoserviceproviderfactory.h
index ff6ab471..28c27ef0 100644
--- a/src/location/maps/qgeoserviceproviderfactory.h
+++ b/src/location/maps/qgeoserviceproviderfactory.h
@@ -55,7 +55,7 @@ class Q_LOCATION_EXPORT QGeoServiceProviderFactory
 public:
     virtual ~QGeoServiceProviderFactory() {}
 
-    virtual QGeocodingManagerEngine *createGeocodingManagerEngine(const QMap<QString, QVariant> &parameters,
+    virtual QGeoCodingManagerEngine *createGeocodingManagerEngine(const QMap<QString, QVariant> &parameters,
             QGeoServiceProvider::Error *error,
             QString *errorString) const;
     virtual QGeoMappingManagerEngine *createMappingManagerEngine(const QMap<QString, QVariant> &parameters,
diff --git a/src/location/places/places.pri b/src/location/places/places.pri
index 4c3a0667..1a3796fc 100644
--- a/src/location/places/places.pri
+++ b/src/location/places/places.pri
@@ -19,7 +19,7 @@ PUBLIC_HEADERS += \
 #result
     places/qplacesearchresult.h \
     places/qplaceresult.h \
-    places/qproposedsearchresult.h \
+    places/qplaceproposedsearchresult.h \
 #request classes
     places/qplacecontentrequest.h \
     places/qplacematchrequest.h \
@@ -47,7 +47,7 @@ PRIVATE_HEADERS += \
     places/qplaceimage_p.h \
     places/qplaceratings_p.h \
     places/qplaceresult_p.h \
-    places/qproposedsearchresult_p.h \
+    places/qplaceproposedsearchresult_p.h \
     places/qplacereview_p.h \
     places/qplacesupplier_p.h \
     places/qplacesearchresult_p.h \
@@ -76,7 +76,7 @@ SOURCES += \
 #result
     places/qplacesearchresult.cpp \
     places/qplaceresult.cpp \
-    places/qproposedsearchresult.cpp \
+    places/qplaceproposedsearchresult.cpp \
 #request classes
     places/qplacecontentrequest.cpp \
     places/qplacematchrequest.cpp \
diff --git a/src/location/places/qproposedsearchresult.cpp b/src/location/places/qplaceproposedsearchresult.cpp
index 94581b89..d2aaf5bb 100644
--- a/src/location/places/qproposedsearchresult.cpp
+++ b/src/location/places/qplaceproposedsearchresult.cpp
@@ -39,38 +39,38 @@
 **
 ****************************************************************************/
 
-#include "qproposedsearchresult.h"
-#include "qproposedsearchresult_p.h"
+#include "qplaceproposedsearchresult.h"
+#include "qplaceproposedsearchresult_p.h"
 
 QT_BEGIN_NAMESPACE
 
-QProposedSearchResultPrivate::QProposedSearchResultPrivate()
+QPlaceProposedSearchResultPrivate::QPlaceProposedSearchResultPrivate()
 {
 }
 
-QProposedSearchResultPrivate::QProposedSearchResultPrivate(const QProposedSearchResultPrivate &other)
+QPlaceProposedSearchResultPrivate::QPlaceProposedSearchResultPrivate(const QPlaceProposedSearchResultPrivate &other)
 :   QPlaceSearchResultPrivate(other), searchRequest(other.searchRequest)
 {
 }
 
-QProposedSearchResultPrivate::~QProposedSearchResultPrivate()
+QPlaceProposedSearchResultPrivate::~QPlaceProposedSearchResultPrivate()
 {
 }
 
-bool QProposedSearchResultPrivate::compare(const QPlaceSearchResultPrivate *other) const
+bool QPlaceProposedSearchResultPrivate::compare(const QPlaceSearchResultPrivate *other) const
 {
-    const QProposedSearchResultPrivate *od = static_cast<const QProposedSearchResultPrivate *>(other);
+    const QPlaceProposedSearchResultPrivate *od = static_cast<const QPlaceProposedSearchResultPrivate *>(other);
     return QPlaceSearchResultPrivate::compare(other) && searchRequest == od->searchRequest;
 }
 
 /*!
-    \class QProposedSearchResult
+    \class QPlaceProposedSearchResult
     \inmodule QtLocation
     \ingroup QtLocation-places
     \ingroup QtLocation-places-data
     \since Qt Location 5.2
 
-    \brief The QProposedSearchResult class represents a search result containing a proposed search.
+    \brief The QPlaceProposedSearchResult class represents a search result containing a proposed search.
 
     \sa QPlaceSearchResult
 */
@@ -78,43 +78,43 @@ bool QProposedSearchResultPrivate::compare(const QPlaceSearchResultPrivate *othe
 /*!
     Constructs a new proposed search result.
 */
-QProposedSearchResult::QProposedSearchResult()
-:   QPlaceSearchResult(new QProposedSearchResultPrivate)
+QPlaceProposedSearchResult::QPlaceProposedSearchResult()
+:   QPlaceSearchResult(new QPlaceProposedSearchResultPrivate)
 {
 }
 
 /*!
-    \fn QProposedSearchResult::QProposedSearchResult(const QPlaceSearchRequest &other)
+    \fn QPlaceProposedSearchResult::QPlaceProposedSearchResult(const QPlaceSearchRequest &other)
 
     Contructs a copy of \a other if possible, otherwise constructs a default proposed search
     result.
 */
-Q_IMPLEMENT_SEARCHRESULT_COPY_CTOR(QProposedSearchResult)
+Q_IMPLEMENT_SEARCHRESULT_COPY_CTOR(QPlaceProposedSearchResult)
 
-Q_IMPLEMENT_SEARCHRESULT_D_FUNC(QProposedSearchResult)
+Q_IMPLEMENT_SEARCHRESULT_D_FUNC(QPlaceProposedSearchResult)
 
 /*!
     Destroys the proposed search result.
 */
-QProposedSearchResult::~QProposedSearchResult()
+QPlaceProposedSearchResult::~QPlaceProposedSearchResult()
 {
 }
 
 /*!
     Returns a place search request that can be used to perform an additional proposed search.
 */
-QPlaceSearchRequest QProposedSearchResult::searchRequest() const
+QPlaceSearchRequest QPlaceProposedSearchResult::searchRequest() const
 {
-    Q_D(const QProposedSearchResult);
+    Q_D(const QPlaceProposedSearchResult);
     return d->searchRequest;
 }
 
 /*!
     Sets the proposed search request to \a request.
 */
-void QProposedSearchResult::setSearchRequest(const QPlaceSearchRequest &request)
+void QPlaceProposedSearchResult::setSearchRequest(const QPlaceSearchRequest &request)
 {
-    Q_D(QProposedSearchResult);
+    Q_D(QPlaceProposedSearchResult);
     d->searchRequest = request;
 }
 
diff --git a/src/location/places/qproposedsearchresult.h b/src/location/places/qplaceproposedsearchresult.h
index 8c937324..ff957b86 100644
--- a/src/location/places/qproposedsearchresult.h
+++ b/src/location/places/qplaceproposedsearchresult.h
@@ -46,29 +46,29 @@
 
 QT_BEGIN_NAMESPACE
 
-class QProposedSearchResultPrivate;
+class QPlaceProposedSearchResultPrivate;
 
-class Q_LOCATION_EXPORT QProposedSearchResult : public QPlaceSearchResult
+class Q_LOCATION_EXPORT QPlaceProposedSearchResult : public QPlaceSearchResult
 {
 public:
-    QProposedSearchResult();
+    QPlaceProposedSearchResult();
 
 #ifdef Q_QDOC
-    QProposedSearchResult(const QPlaceSearchRequest &other);
+    QPlaceProposedSearchResult(const QPlaceSearchRequest &other);
 #else
-    Q_DECLARE_SEARCHRESULT_COPY_CTOR(QProposedSearchResult)
+    Q_DECLARE_SEARCHRESULT_COPY_CTOR(QPlaceProposedSearchResult)
 #endif
 
-    ~QProposedSearchResult();
+    ~QPlaceProposedSearchResult();
 
     QPlaceSearchRequest searchRequest() const;
     void setSearchRequest(const QPlaceSearchRequest &request);
 
 private:
-    Q_DECLARE_SEARCHRESULT_D_FUNC(QProposedSearchResult)
+    Q_DECLARE_SEARCHRESULT_D_FUNC(QPlaceProposedSearchResult)
 };
 
-Q_DECLARE_TYPEINFO(QProposedSearchResult, Q_MOVABLE_TYPE);
+Q_DECLARE_TYPEINFO(QPlaceProposedSearchResult, Q_MOVABLE_TYPE);
 
 QT_END_NAMESPACE
 
diff --git a/src/location/places/qproposedsearchresult_p.h b/src/location/places/qplaceproposedsearchresult_p.h
index 37df3447..2241341b 100644
--- a/src/location/places/qproposedsearchresult_p.h
+++ b/src/location/places/qplaceproposedsearchresult_p.h
@@ -46,17 +46,17 @@
 
 QT_BEGIN_NAMESPACE
 
-class QProposedSearchResultPrivate : public QPlaceSearchResultPrivate
+class QPlaceProposedSearchResultPrivate : public QPlaceSearchResultPrivate
 {
 public:
-    QProposedSearchResultPrivate();
-    QProposedSearchResultPrivate(const QProposedSearchResultPrivate &other);
+    QPlaceProposedSearchResultPrivate();
+    QPlaceProposedSearchResultPrivate(const QPlaceProposedSearchResultPrivate &other);
 
-    ~QProposedSearchResultPrivate();
+    ~QPlaceProposedSearchResultPrivate();
 
     bool compare(const QPlaceSearchResultPrivate *other) const Q_DECL_OVERRIDE;
 
-    Q_DEFINE_SEARCHRESULT_PRIVATE_HELPER(QProposedSearchResult, QPlaceSearchResult::ProposedSearchResult)
+    Q_DEFINE_SEARCHRESULT_PRIVATE_HELPER(QPlaceProposedSearchResult, QPlaceSearchResult::ProposedSearchResult)
 
     QPlaceSearchRequest searchRequest;
 };
diff --git a/src/plugins/geoservices/nokia/placesv2/qplacesearchreplyimpl.cpp b/src/plugins/geoservices/nokia/placesv2/qplacesearchreplyimpl.cpp
index 41f1c73e..7bd20599 100644
--- a/src/plugins/geoservices/nokia/placesv2/qplacesearchreplyimpl.cpp
+++ b/src/plugins/geoservices/nokia/placesv2/qplacesearchreplyimpl.cpp
@@ -57,7 +57,7 @@
 #include <QtCore/QJsonArray>
 #include <QtLocation/QPlaceIcon>
 #include <QtLocation/QPlaceResult>
-#include <QtLocation/QProposedSearchResult>
+#include <QtLocation/QPlaceProposedSearchResult>
 
 #include <QtCore/QDebug>
 
@@ -210,9 +210,9 @@ QPlaceResult QPlaceSearchReplyImpl::parsePlaceResult(const QJsonObject &item) co
     return result;
 }
 
-QProposedSearchResult QPlaceSearchReplyImpl::parseSearchResult(const QJsonObject &item) const
+QPlaceProposedSearchResult QPlaceSearchReplyImpl::parseSearchResult(const QJsonObject &item) const
 {
-    QProposedSearchResult result;
+    QPlaceProposedSearchResult result;
 
     result.setTitle(item.value(QLatin1String("title")).toString());
 
diff --git a/src/plugins/geoservices/nokia/placesv2/qplacesearchreplyimpl.h b/src/plugins/geoservices/nokia/placesv2/qplacesearchreplyimpl.h
index a7871653..a888ef31 100644
--- a/src/plugins/geoservices/nokia/placesv2/qplacesearchreplyimpl.h
+++ b/src/plugins/geoservices/nokia/placesv2/qplacesearchreplyimpl.h
@@ -56,7 +56,7 @@ QT_BEGIN_NAMESPACE
 
 class QPlaceManagerEngineNokiaV2;
 class QPlaceResult;
-class QProposedSearchResult;
+class QPlaceProposedSearchResult;
 
 class QPlaceSearchReplyImpl : public QPlaceSearchReply
 {
@@ -76,7 +76,7 @@ private slots:
 
 private:
     QPlaceResult parsePlaceResult(const QJsonObject &item) const;
-    QProposedSearchResult parseSearchResult(const QJsonObject &item) const;
+    QPlaceProposedSearchResult parseSearchResult(const QJsonObject &item) const;
 
     QNetworkReply *m_reply;
     QPlaceManagerEngineNokiaV2 *m_engine;
diff --git a/src/plugins/geoservices/nokia/qgeocodereply_nokia.cpp b/src/plugins/geoservices/nokia/qgeocodereply_nokia.cpp
index 4995358b..cb76fbca 100644
--- a/src/plugins/geoservices/nokia/qgeocodereply_nokia.cpp
+++ b/src/plugins/geoservices/nokia/qgeocodereply_nokia.cpp
@@ -53,9 +53,9 @@
 
 QT_BEGIN_NAMESPACE
 
-QGeocodeReplyNokia::QGeocodeReplyNokia(QNetworkReply *reply, int limit, int offset,
+QGeoCodeReplyNokia::QGeoCodeReplyNokia(QNetworkReply *reply, int limit, int offset,
                                        const QGeoShape &viewport, QObject *parent)
-        : QGeocodeReply(parent),
+        : QGeoCodeReply(parent),
         m_reply(reply)
 {
     connect(m_reply,
@@ -73,12 +73,12 @@ QGeocodeReplyNokia::QGeocodeReplyNokia(QNetworkReply *reply, int limit, int offs
     setViewport(viewport);
 }
 
-QGeocodeReplyNokia::~QGeocodeReplyNokia()
+QGeoCodeReplyNokia::~QGeoCodeReplyNokia()
 {
     //TODO: possible mem leak -> m_reply->deleteLater() ?
 }
 
-void QGeocodeReplyNokia::abort()
+void QGeoCodeReplyNokia::abort()
 {
     if (!m_reply)
         return;
@@ -89,7 +89,7 @@ void QGeocodeReplyNokia::abort()
     m_reply = 0;
 }
 
-void QGeocodeReplyNokia::networkFinished()
+void QGeoCodeReplyNokia::networkFinished()
 {
     if (!m_reply)
         return;
@@ -115,21 +115,21 @@ void QGeocodeReplyNokia::networkFinished()
         setLocations(locations);
         setFinished(true);
     } else {
-        setError(QGeocodeReply::ParseError, parser.errorString());
+        setError(QGeoCodeReply::ParseError, parser.errorString());
     }
 
     m_reply->deleteLater();
     m_reply = 0;
 }
 
-void QGeocodeReplyNokia::networkError(QNetworkReply::NetworkError error)
+void QGeoCodeReplyNokia::networkError(QNetworkReply::NetworkError error)
 {
     Q_UNUSED(error)
 
     if (!m_reply)
         return;
 
-    setError(QGeocodeReply::CommunicationError, m_reply->errorString());
+    setError(QGeoCodeReply::CommunicationError, m_reply->errorString());
 
     m_reply->deleteLater();
     m_reply = 0;
diff --git a/src/plugins/geoservices/nokia/qgeocodereply_nokia.h b/src/plugins/geoservices/nokia/qgeocodereply_nokia.h
index 38c44a3e..6b72cd40 100644
--- a/src/plugins/geoservices/nokia/qgeocodereply_nokia.h
+++ b/src/plugins/geoservices/nokia/qgeocodereply_nokia.h
@@ -54,12 +54,12 @@
 
 QT_BEGIN_NAMESPACE
 
-class QGeocodeReplyNokia : public QGeocodeReply
+class QGeoCodeReplyNokia : public QGeoCodeReply
 {
     Q_OBJECT
 public:
-    QGeocodeReplyNokia(QNetworkReply *reply, int limit, int offset, const QGeoShape &viewport, QObject *parent = 0);
-    ~QGeocodeReplyNokia();
+    QGeoCodeReplyNokia(QNetworkReply *reply, int limit, int offset, const QGeoShape &viewport, QObject *parent = 0);
+    ~QGeoCodeReplyNokia();
 
     void abort();
 
diff --git a/src/plugins/geoservices/nokia/qgeocodingmanagerengine_nokia.cpp b/src/plugins/geoservices/nokia/qgeocodingmanagerengine_nokia.cpp
index 833e5765..d00f4fb9 100644
--- a/src/plugins/geoservices/nokia/qgeocodingmanagerengine_nokia.cpp
+++ b/src/plugins/geoservices/nokia/qgeocodingmanagerengine_nokia.cpp
@@ -61,12 +61,12 @@
 
 QT_BEGIN_NAMESPACE
 
-QGeocodingManagerEngineNokia::QGeocodingManagerEngineNokia(
+QGeoCodingManagerEngineNokia::QGeoCodingManagerEngineNokia(
         QGeoNetworkAccessManager *networkManager,
         const QMap<QString, QVariant> &parameters,
         QGeoServiceProvider::Error *error,
         QString *errorString)
-        : QGeocodingManagerEngine(parameters)
+        : QGeoCodingManagerEngine(parameters)
         , m_networkManager(networkManager)
         , m_uriProvider(new QGeoUriProvider(this, parameters, "geocoding.host", GEOCODING_HOST, GEOCODING_HOST_CN))
 {
@@ -88,9 +88,9 @@ QGeocodingManagerEngineNokia::QGeocodingManagerEngineNokia(
         *errorString = "";
 }
 
-QGeocodingManagerEngineNokia::~QGeocodingManagerEngineNokia() {}
+QGeoCodingManagerEngineNokia::~QGeoCodingManagerEngineNokia() {}
 
-QString QGeocodingManagerEngineNokia::getAuthenticationString() const
+QString QGeoCodingManagerEngineNokia::getAuthenticationString() const
 {
     QString authenticationString;
 
@@ -106,8 +106,8 @@ QString QGeocodingManagerEngineNokia::getAuthenticationString() const
 }
 
 
-QGeocodeReply *QGeocodingManagerEngineNokia::geocode(const QGeoAddress &address,
-        const QGeoShape &bounds)
+QGeoCodeReply *QGeoCodingManagerEngineNokia::geocode(const QGeoAddress &address,
+                                                     const QGeoShape &bounds)
 {
     QString requestString = "http://";
     requestString += m_uriProvider->getCurrentHost();
@@ -175,8 +175,8 @@ QGeocodeReply *QGeocodingManagerEngineNokia::geocode(const QGeoAddress &address,
     return geocode(requestString, bounds);
 }
 
-QGeocodeReply *QGeocodingManagerEngineNokia::reverseGeocode(const QGeoCoordinate &coordinate,
-        const QGeoShape &bounds)
+QGeoCodeReply *QGeoCodingManagerEngineNokia::reverseGeocode(const QGeoCoordinate &coordinate,
+                                                            const QGeoShape &bounds)
 {
     QString requestString = "http://";
     requestString += m_uriProvider->getCurrentHost();
@@ -195,10 +195,10 @@ QGeocodeReply *QGeocodingManagerEngineNokia::reverseGeocode(const QGeoCoordinate
     return geocode(requestString, bounds);
 }
 
-QGeocodeReply *QGeocodingManagerEngineNokia::geocode(const QString &address,
-        int limit,
-        int offset,
-        const QGeoShape &bounds)
+QGeoCodeReply *QGeoCodingManagerEngineNokia::geocode(const QString &address,
+                                                     int limit,
+                                                     int offset,
+                                                     const QGeoShape &bounds)
 {
     QString requestString = "http://";
     requestString += m_uriProvider->getCurrentHost();
@@ -225,13 +225,13 @@ QGeocodeReply *QGeocodingManagerEngineNokia::geocode(const QString &address,
     return geocode(requestString, bounds, limit, offset);
 }
 
-QGeocodeReply *QGeocodingManagerEngineNokia::geocode(QString requestString,
-        const QGeoShape &bounds,
-        int limit,
-        int offset)
+QGeoCodeReply *QGeoCodingManagerEngineNokia::geocode(QString requestString,
+                                                     const QGeoShape &bounds,
+                                                     int limit,
+                                                     int offset)
 {
     QNetworkReply *networkReply = m_networkManager->get(QNetworkRequest(QUrl(requestString)));
-    QGeocodeReplyNokia *reply = new QGeocodeReplyNokia(networkReply, limit, offset, bounds, this);
+    QGeoCodeReplyNokia *reply = new QGeoCodeReplyNokia(networkReply, limit, offset, bounds, this);
 
     connect(reply,
             SIGNAL(finished()),
@@ -239,14 +239,14 @@ QGeocodeReply *QGeocodingManagerEngineNokia::geocode(QString requestString,
             SLOT(placesFinished()));
 
     connect(reply,
-            SIGNAL(error(QGeocodeReply::Error, QString)),
+            SIGNAL(error(QGeoCodeReply::Error, QString)),
             this,
-            SLOT(placesError(QGeocodeReply::Error, QString)));
+            SLOT(placesError(QGeoCodeReply::Error, QString)));
 
     return reply;
 }
 
-QString QGeocodingManagerEngineNokia::trimDouble(double degree, int decimalDigits)
+QString QGeoCodingManagerEngineNokia::trimDouble(double degree, int decimalDigits)
 {
     QString sDegree = QString::number(degree, 'g', decimalDigits);
 
@@ -258,14 +258,14 @@ QString QGeocodingManagerEngineNokia::trimDouble(double degree, int decimalDigit
         return QString::number(degree, 'g', decimalDigits + index);
 }
 
-void QGeocodingManagerEngineNokia::placesFinished()
+void QGeoCodingManagerEngineNokia::placesFinished()
 {
-    QGeocodeReply *reply = qobject_cast<QGeocodeReply *>(sender());
+    QGeoCodeReply *reply = qobject_cast<QGeoCodeReply *>(sender());
 
     if (!reply)
         return;
 
-    if (receivers(SIGNAL(finished(QGeocodeReply*))) == 0) {
+    if (receivers(SIGNAL(finished(QGeoCodeReply*))) == 0) {
         reply->deleteLater();
         return;
     }
@@ -273,14 +273,14 @@ void QGeocodingManagerEngineNokia::placesFinished()
     emit finished(reply);
 }
 
-void QGeocodingManagerEngineNokia::placesError(QGeocodeReply::Error error, const QString &errorString)
+void QGeoCodingManagerEngineNokia::placesError(QGeoCodeReply::Error error, const QString &errorString)
 {
-    QGeocodeReply *reply = qobject_cast<QGeocodeReply *>(sender());
+    QGeoCodeReply *reply = qobject_cast<QGeoCodeReply *>(sender());
 
     if (!reply)
         return;
 
-    if (receivers(SIGNAL(error(QGeocodeReply *, QGeocodeReply::Error, QString))) == 0) {
+    if (receivers(SIGNAL(error(QGeoCodeReply *, QGeoCodeReply::Error, QString))) == 0) {
         reply->deleteLater();
         return;
     }
@@ -288,7 +288,7 @@ void QGeocodingManagerEngineNokia::placesError(QGeocodeReply::Error error, const
     emit this->error(reply, error, errorString);
 }
 
-QString QGeocodingManagerEngineNokia::languageToMarc(QLocale::Language language)
+QString QGeoCodingManagerEngineNokia::languageToMarc(QLocale::Language language)
 {
     uint offset = 3 * (uint(language));
     if (language == QLocale::C || offset + 3 > sizeof(marc_language_code_list))
diff --git a/src/plugins/geoservices/nokia/qgeocodingmanagerengine_nokia.h b/src/plugins/geoservices/nokia/qgeocodingmanagerengine_nokia.h
index 25074a93..6b9bf1e2 100644
--- a/src/plugins/geoservices/nokia/qgeocodingmanagerengine_nokia.h
+++ b/src/plugins/geoservices/nokia/qgeocodingmanagerengine_nokia.h
@@ -61,33 +61,33 @@ QT_BEGIN_NAMESPACE
 class QGeoNetworkAccessManager;
 class QGeoUriProvider;
 
-class QGeocodingManagerEngineNokia : public QGeocodingManagerEngine
+class QGeoCodingManagerEngineNokia : public QGeoCodingManagerEngine
 {
     Q_OBJECT
 public:
-    QGeocodingManagerEngineNokia(QGeoNetworkAccessManager *networkManager,
+    QGeoCodingManagerEngineNokia(QGeoNetworkAccessManager *networkManager,
                                  const QMap<QString, QVariant> &parameters,
                                  QGeoServiceProvider::Error *error,
                                  QString *errorString);
-    ~QGeocodingManagerEngineNokia();
+    ~QGeoCodingManagerEngineNokia();
 
-    QGeocodeReply *geocode(const QGeoAddress &address,
+    QGeoCodeReply *geocode(const QGeoAddress &address,
                              const QGeoShape &bounds);
-    QGeocodeReply *reverseGeocode(const QGeoCoordinate &coordinate,
+    QGeoCodeReply *reverseGeocode(const QGeoCoordinate &coordinate,
                                     const QGeoShape &bounds);
 
-    QGeocodeReply *geocode(const QString &searchString,
+    QGeoCodeReply *geocode(const QString &searchString,
                             int limit,
                             int offset,
                             const QGeoShape &bounds);
 
 private Q_SLOTS:
     void placesFinished();
-    void placesError(QGeocodeReply::Error error, const QString &errorString);
+    void placesError(QGeoCodeReply::Error error, const QString &errorString);
 
 private:
     static QString trimDouble(double degree, int decimalDigits = 10);
-    QGeocodeReply *geocode(QString requestString, const QGeoShape &bounds, int limit = -1, int offset = 0);
+    QGeoCodeReply *geocode(QString requestString, const QGeoShape &bounds, int limit = -1, int offset = 0);
     QString languageToMarc(QLocale::Language language);
     QString getAuthenticationString() const;
 
diff --git a/src/plugins/geoservices/nokia/qgeoserviceproviderplugin_nokia.cpp b/src/plugins/geoservices/nokia/qgeoserviceproviderplugin_nokia.cpp
index 7e8e7a6d..6d8967d5 100644
--- a/src/plugins/geoservices/nokia/qgeoserviceproviderplugin_nokia.cpp
+++ b/src/plugins/geoservices/nokia/qgeoserviceproviderplugin_nokia.cpp
@@ -113,12 +113,12 @@ namespace
     }
 }
 
-QGeocodingManagerEngine *QGeoServiceProviderFactoryNokia::createGeocodingManagerEngine(
+QGeoCodingManagerEngine *QGeoServiceProviderFactoryNokia::createGeocodingManagerEngine(
         const QVariantMap &parameters,
         QGeoServiceProvider::Error *error,
         QString *errorString) const
 {
-    return CreateInstanceOf<QGeocodingManagerEngineNokia>(parameters, error, errorString);
+    return CreateInstanceOf<QGeoCodingManagerEngineNokia>(parameters, error, errorString);
 }
 
 QGeoMappingManagerEngine *QGeoServiceProviderFactoryNokia::createMappingManagerEngine(
diff --git a/src/plugins/geoservices/nokia/qgeoserviceproviderplugin_nokia.h b/src/plugins/geoservices/nokia/qgeoserviceproviderplugin_nokia.h
index 503f9f96..dfe75968 100644
--- a/src/plugins/geoservices/nokia/qgeoserviceproviderplugin_nokia.h
+++ b/src/plugins/geoservices/nokia/qgeoserviceproviderplugin_nokia.h
@@ -64,15 +64,15 @@ class QGeoServiceProviderFactoryNokia : public QObject, public QGeoServiceProvid
                       FILE "nokia_plugin.json")
 
 public:
-    QGeocodingManagerEngine *createGeocodingManagerEngine(const QVariantMap &parameters,
-            QGeoServiceProvider::Error *error,
-            QString *errorString) const;
+    QGeoCodingManagerEngine *createGeocodingManagerEngine(const QVariantMap &parameters,
+                                                          QGeoServiceProvider::Error *error,
+                                                          QString *errorString) const;
     QGeoMappingManagerEngine *createMappingManagerEngine(const QVariantMap &parameters,
-            QGeoServiceProvider::Error *error,
-            QString *errorString) const;
+                                                         QGeoServiceProvider::Error *error,
+                                                         QString *errorString) const;
     QGeoRoutingManagerEngine *createRoutingManagerEngine(const QVariantMap &parameters,
-            QGeoServiceProvider::Error *error,
-            QString *errorString) const;
+                                                         QGeoServiceProvider::Error *error,
+                                                         QString *errorString) const;
     QPlaceManagerEngine *createPlaceManagerEngine(const QVariantMap &parameters,
                                                   QGeoServiceProvider::Error *error,
                                                   QString *errorString) const;
diff --git a/src/plugins/geoservices/osm/qgeocodereplyosm.cpp b/src/plugins/geoservices/osm/qgeocodereplyosm.cpp
index 39b5339b..afa48028 100644
--- a/src/plugins/geoservices/osm/qgeocodereplyosm.cpp
+++ b/src/plugins/geoservices/osm/qgeocodereplyosm.cpp
@@ -51,8 +51,8 @@
 
 QT_BEGIN_NAMESPACE
 
-QGeocodeReplyOsm::QGeocodeReplyOsm(QNetworkReply *reply, QObject *parent)
-:   QGeocodeReply(parent), m_reply(reply)
+QGeoCodeReplyOsm::QGeoCodeReplyOsm(QNetworkReply *reply, QObject *parent)
+:   QGeoCodeReply(parent), m_reply(reply)
 {
     connect(m_reply, SIGNAL(finished()), this, SLOT(networkReplyFinished()));
     connect(m_reply, SIGNAL(error(QNetworkReply::NetworkError)),
@@ -62,13 +62,13 @@ QGeocodeReplyOsm::QGeocodeReplyOsm(QNetworkReply *reply, QObject *parent)
     setOffset(0);
 }
 
-QGeocodeReplyOsm::~QGeocodeReplyOsm()
+QGeoCodeReplyOsm::~QGeoCodeReplyOsm()
 {
     if (m_reply)
         m_reply->deleteLater();
 }
 
-void QGeocodeReplyOsm::abort()
+void QGeoCodeReplyOsm::abort()
 {
     if (!m_reply)
         return;
@@ -79,7 +79,7 @@ void QGeocodeReplyOsm::abort()
     m_reply = 0;
 }
 
-void QGeocodeReplyOsm::networkReplyFinished()
+void QGeoCodeReplyOsm::networkReplyFinished()
 {
     if (!m_reply)
         return;
@@ -173,14 +173,14 @@ void QGeocodeReplyOsm::networkReplyFinished()
     m_reply = 0;
 }
 
-void QGeocodeReplyOsm::networkReplyError(QNetworkReply::NetworkError error)
+void QGeoCodeReplyOsm::networkReplyError(QNetworkReply::NetworkError error)
 {
     Q_UNUSED(error)
 
     if (!m_reply)
         return;
 
-    setError(QGeocodeReply::CommunicationError, m_reply->errorString());
+    setError(QGeoCodeReply::CommunicationError, m_reply->errorString());
 
     m_reply->deleteLater();
     m_reply = 0;
diff --git a/src/plugins/geoservices/osm/qgeocodereplyosm.h b/src/plugins/geoservices/osm/qgeocodereplyosm.h
index 669ee40d..d089838b 100644
--- a/src/plugins/geoservices/osm/qgeocodereplyosm.h
+++ b/src/plugins/geoservices/osm/qgeocodereplyosm.h
@@ -43,17 +43,17 @@
 #define QGEOCODEREPLYOSM_H
 
 #include <QtNetwork/QNetworkReply>
-#include <QtLocation/QGeocodeReply>
+#include <QtLocation/QGeoCodeReply>
 
 QT_BEGIN_NAMESPACE
 
-class QGeocodeReplyOsm : public QGeocodeReply
+class QGeoCodeReplyOsm : public QGeoCodeReply
 {
     Q_OBJECT
 
 public:
-    explicit QGeocodeReplyOsm(QNetworkReply *reply, QObject *parent = 0);
-    ~QGeocodeReplyOsm();
+    explicit QGeoCodeReplyOsm(QNetworkReply *reply, QObject *parent = 0);
+    ~QGeoCodeReplyOsm();
 
     void abort();
 
diff --git a/src/plugins/geoservices/osm/qgeocodingmanagerengineosm.cpp b/src/plugins/geoservices/osm/qgeocodingmanagerengineosm.cpp
index 05bc97dd..08288552 100644
--- a/src/plugins/geoservices/osm/qgeocodingmanagerengineosm.cpp
+++ b/src/plugins/geoservices/osm/qgeocodingmanagerengineosm.cpp
@@ -72,10 +72,10 @@ static QString boundingBoxToLtrb(const QGeoRectangle &rect)
            QString::number(rect.bottomRight().latitude());
 }
 
-QGeocodingManagerEngineOsm::QGeocodingManagerEngineOsm(const QVariantMap &parameters,
+QGeoCodingManagerEngineOsm::QGeoCodingManagerEngineOsm(const QVariantMap &parameters,
                                                        QGeoServiceProvider::Error *error,
                                                        QString *errorString)
-:   QGeocodingManagerEngine(parameters), m_networkManager(new QNetworkAccessManager(this))
+:   QGeoCodingManagerEngine(parameters), m_networkManager(new QNetworkAccessManager(this))
 {
     if (parameters.contains(QStringLiteral("useragent")))
         m_userAgent = parameters.value(QStringLiteral("useragent")).toString().toLatin1();
@@ -86,16 +86,16 @@ QGeocodingManagerEngineOsm::QGeocodingManagerEngineOsm(const QVariantMap &parame
     errorString->clear();
 }
 
-QGeocodingManagerEngineOsm::~QGeocodingManagerEngineOsm()
+QGeoCodingManagerEngineOsm::~QGeoCodingManagerEngineOsm()
 {
 }
 
-QGeocodeReply *QGeocodingManagerEngineOsm::geocode(const QGeoAddress &address, const QGeoShape &bounds)
+QGeoCodeReply *QGeoCodingManagerEngineOsm::geocode(const QGeoAddress &address, const QGeoShape &bounds)
 {
     return geocode(addressToQuery(address), -1, -1, bounds);
 }
 
-QGeocodeReply *QGeocodingManagerEngineOsm::geocode(const QString &address, int limit, int offset, const QGeoShape &bounds)
+QGeoCodeReply *QGeoCodingManagerEngineOsm::geocode(const QString &address, int limit, int offset, const QGeoShape &bounds)
 {
     Q_UNUSED(offset)
 
@@ -122,16 +122,16 @@ QGeocodeReply *QGeocodingManagerEngineOsm::geocode(const QString &address, int l
 
     QNetworkReply *reply = m_networkManager->get(request);
 
-    QGeocodeReplyOsm *geocodeReply = new QGeocodeReplyOsm(reply, this);
+    QGeoCodeReplyOsm *geocodeReply = new QGeoCodeReplyOsm(reply, this);
 
     connect(geocodeReply, SIGNAL(finished()), this, SLOT(replyFinished()));
-    connect(geocodeReply, SIGNAL(error(QGeocodeReply::Error,QString)),
-            this, SLOT(replyError(QGeocodeReply::Error,QString)));
+    connect(geocodeReply, SIGNAL(error(QGeoCodeReply::Error,QString)),
+            this, SLOT(replyError(QGeoCodeReply::Error,QString)));
 
     return geocodeReply;
 }
 
-QGeocodeReply *QGeocodingManagerEngineOsm::reverseGeocode(const QGeoCoordinate &coordinate,
+QGeoCodeReply *QGeoCodingManagerEngineOsm::reverseGeocode(const QGeoCoordinate &coordinate,
                                                           const QGeoShape &bounds)
 {
     Q_UNUSED(bounds)
@@ -153,25 +153,25 @@ QGeocodeReply *QGeocodingManagerEngineOsm::reverseGeocode(const QGeoCoordinate &
 
     QNetworkReply *reply = m_networkManager->get(request);
 
-    QGeocodeReplyOsm *geocodeReply = new QGeocodeReplyOsm(reply, this);
+    QGeoCodeReplyOsm *geocodeReply = new QGeoCodeReplyOsm(reply, this);
 
     connect(geocodeReply, SIGNAL(finished()), this, SLOT(replyFinished()));
-    connect(geocodeReply, SIGNAL(error(QGeocodeReply::Error,QString)),
-            this, SLOT(replyError(QGeocodeReply::Error,QString)));
+    connect(geocodeReply, SIGNAL(error(QGeoCodeReply::Error,QString)),
+            this, SLOT(replyError(QGeoCodeReply::Error,QString)));
 
     return geocodeReply;
 }
 
-void QGeocodingManagerEngineOsm::replyFinished()
+void QGeoCodingManagerEngineOsm::replyFinished()
 {
-    QGeocodeReply *reply = qobject_cast<QGeocodeReply *>(sender());
+    QGeoCodeReply *reply = qobject_cast<QGeoCodeReply *>(sender());
     if (reply)
         emit finished(reply);
 }
 
-void QGeocodingManagerEngineOsm::replyError(QGeocodeReply::Error errorCode, const QString &errorString)
+void QGeoCodingManagerEngineOsm::replyError(QGeoCodeReply::Error errorCode, const QString &errorString)
 {
-    QGeocodeReply *reply = qobject_cast<QGeocodeReply *>(sender());
+    QGeoCodeReply *reply = qobject_cast<QGeoCodeReply *>(sender());
     if (reply)
         emit error(reply, errorCode, errorString);
 }
diff --git a/src/plugins/geoservices/osm/qgeocodingmanagerengineosm.h b/src/plugins/geoservices/osm/qgeocodingmanagerengineosm.h
index 40b4aeae..7961cc2b 100644
--- a/src/plugins/geoservices/osm/qgeocodingmanagerengineosm.h
+++ b/src/plugins/geoservices/osm/qgeocodingmanagerengineosm.h
@@ -43,31 +43,31 @@
 #define QGEOCODINGMANAGERENGINEOSM_H
 
 #include <QtLocation/QGeoServiceProvider>
-#include <QtLocation/QGeocodingManagerEngine>
-#include <QtLocation/QGeocodeReply>
+#include <QtLocation/QGeoCodingManagerEngine>
+#include <QtLocation/QGeoCodeReply>
 
 QT_BEGIN_NAMESPACE
 
 class QNetworkAccessManager;
 
-class QGeocodingManagerEngineOsm : public QGeocodingManagerEngine
+class QGeoCodingManagerEngineOsm : public QGeoCodingManagerEngine
 {
     Q_OBJECT
 
 public:
-    QGeocodingManagerEngineOsm(const QVariantMap &parameters, QGeoServiceProvider::Error *error,
+    QGeoCodingManagerEngineOsm(const QVariantMap &parameters, QGeoServiceProvider::Error *error,
                                QString *errorString);
-    ~QGeocodingManagerEngineOsm();
+    ~QGeoCodingManagerEngineOsm();
 
-    QGeocodeReply *geocode(const QGeoAddress &address, const QGeoShape &bounds) Q_DECL_OVERRIDE;
-    QGeocodeReply *geocode(const QString &address, int limit, int offset,
+    QGeoCodeReply *geocode(const QGeoAddress &address, const QGeoShape &bounds) Q_DECL_OVERRIDE;
+    QGeoCodeReply *geocode(const QString &address, int limit, int offset,
                            const QGeoShape &bounds) Q_DECL_OVERRIDE;
-    QGeocodeReply *reverseGeocode(const QGeoCoordinate &coordinate,
+    QGeoCodeReply *reverseGeocode(const QGeoCoordinate &coordinate,
                                   const QGeoShape &bounds) Q_DECL_OVERRIDE;
 
 private Q_SLOTS:
     void replyFinished();
-    void replyError(QGeocodeReply::Error errorCode, const QString &errorString);
+    void replyError(QGeoCodeReply::Error errorCode, const QString &errorString);
 
 private:
     QNetworkAccessManager *m_networkManager;
diff --git a/src/plugins/geoservices/osm/qgeoserviceproviderpluginosm.cpp b/src/plugins/geoservices/osm/qgeoserviceproviderpluginosm.cpp
index 184f38f1..b8e79684 100644
--- a/src/plugins/geoservices/osm/qgeoserviceproviderpluginosm.cpp
+++ b/src/plugins/geoservices/osm/qgeoserviceproviderpluginosm.cpp
@@ -48,10 +48,10 @@
 
 QT_BEGIN_NAMESPACE
 
-QGeocodingManagerEngine *QGeoServiceProviderFactoryOsm::createGeocodingManagerEngine(
+QGeoCodingManagerEngine *QGeoServiceProviderFactoryOsm::createGeocodingManagerEngine(
     const QVariantMap &parameters, QGeoServiceProvider::Error *error, QString *errorString) const
 {
-    return new QGeocodingManagerEngineOsm(parameters, error, errorString);
+    return new QGeoCodingManagerEngineOsm(parameters, error, errorString);
 }
 
 QGeoMappingManagerEngine *QGeoServiceProviderFactoryOsm::createMappingManagerEngine(
diff --git a/src/plugins/geoservices/osm/qgeoserviceproviderpluginosm.h b/src/plugins/geoservices/osm/qgeoserviceproviderpluginosm.h
index 353ae561..f95b451d 100644
--- a/src/plugins/geoservices/osm/qgeoserviceproviderpluginosm.h
+++ b/src/plugins/geoservices/osm/qgeoserviceproviderpluginosm.h
@@ -55,7 +55,7 @@ class QGeoServiceProviderFactoryOsm: public QObject, public QGeoServiceProviderF
                       FILE "osm_plugin.json")
 
 public:
-    QGeocodingManagerEngine *createGeocodingManagerEngine(const QVariantMap &parameters,
+    QGeoCodingManagerEngine *createGeocodingManagerEngine(const QVariantMap &parameters,
                                                           QGeoServiceProvider::Error *error,
                                                           QString *errorString) const;
     QGeoMappingManagerEngine *createMappingManagerEngine(const QVariantMap &parameters,
diff --git a/tests/auto/geotestplugin/qgeocodingmanagerengine_test.h b/tests/auto/geotestplugin/qgeocodingmanagerengine_test.h
index 19d61629..29058c83 100644
--- a/tests/auto/geotestplugin/qgeocodingmanagerengine_test.h
+++ b/tests/auto/geotestplugin/qgeocodingmanagerengine_test.h
@@ -57,11 +57,11 @@
 QT_USE_NAMESPACE
 
 
-class GeocodeReplyTest :public QGeocodeReply
+class GeocodeReplyTest :public QGeoCodeReply
 {
     Q_OBJECT
 public:
-    GeocodeReplyTest(QObject *parent=0):QGeocodeReply (parent) {}
+    GeocodeReplyTest(QObject *parent = 0) : QGeoCodeReply (parent) {}
 
     void  callAddLocation ( const QGeoLocation & location ) {addLocation(location);}
     void  callSetError ( Error error, const QString & errorString ) {setError(error, errorString);}
@@ -77,20 +77,20 @@ Q_SIGNALS:
     void aborted();
 };
 
-class QGeocodingManagerEngineTest: public QGeocodingManagerEngine
+class QGeoCodingManagerEngineTest: public QGeoCodingManagerEngine
 
 {
 Q_OBJECT
 public:
-    QGeocodingManagerEngineTest(const QMap<QString, QVariant> &parameters,
-        QGeoServiceProvider::Error *error, QString *errorString) :
-        QGeocodingManagerEngine(parameters),
-        validateWellKnownValues_(false),
-        finishRequestImmediately_(true),
-        supported_(true),
-        geocodeReply_(0),
-        timerId_(0),
-        errorCode_(QGeocodeReply::NoError)
+    QGeoCodingManagerEngineTest(const QMap<QString, QVariant> &parameters,
+                                QGeoServiceProvider::Error *error, QString *errorString) :
+                                QGeoCodingManagerEngine(parameters),
+                                validateWellKnownValues_(false),
+                                finishRequestImmediately_(true),
+                                supported_(true),
+                                geocodeReply_(0),
+                                timerId_(0),
+                                errorCode_(QGeoCodeReply::NoError)
     {
         Q_UNUSED(error)
         Q_UNUSED(errorString)
@@ -104,10 +104,10 @@ public:
         setLocale(QLocale (QLocale::German, QLocale::Germany));
     }
 
-    QGeocodeReply* geocode(const QString &searchString,
-                            int limit = -1,
-                            int offset = 0,
-                            const QGeoShape &bounds = QGeoShape())
+    QGeoCodeReply* geocode(const QString &searchString,
+                           int limit = -1,
+                           int offset = 0,
+                           const QGeoShape &bounds = QGeoShape())
     {
         geocodeReply_ = new GeocodeReplyTest();
         connect(geocodeReply_, SIGNAL(aborted()), this, SLOT(requestAborted()));
@@ -115,13 +115,13 @@ public:
 
         if (searchString.length() == 1) {
             errorString_ = searchString;
-            errorCode_ = (QGeocodeReply::Error)searchString.toInt();
+            errorCode_ = (QGeoCodeReply::Error)searchString.toInt();
         } else {
             errorString_ = "";
-            errorCode_ = QGeocodeReply::NoError;
+            errorCode_ = QGeoCodeReply::NoError;
         }
 
-        if (errorCode_ == QGeocodeReply::NoError)
+        if (errorCode_ == QGeoCodeReply::NoError)
             setLocations(geocodeReply_, searchString, limit, offset);
 
         if (finishRequestImmediately_) {
@@ -136,10 +136,10 @@ public:
             Q_ASSERT(timerId_ == 0);
             timerId_ = startTimer(200);
         }
-        return static_cast<QGeocodeReply*>(geocodeReply_);
+        return static_cast<QGeoCodeReply*>(geocodeReply_);
     }
 
-    QGeocodeReply*  geocode ( const QGeoAddress & address, const QGeoShape &bounds )
+    QGeoCodeReply* geocode(const QGeoAddress & address, const QGeoShape &bounds)
     {
         geocodeReply_ = new GeocodeReplyTest();
         connect(geocodeReply_, SIGNAL(aborted()), this, SLOT(requestAborted()));
@@ -147,17 +147,17 @@ public:
 
         if (address.street().startsWith("error")) {
             errorString_ = address.street();
-            errorCode_ = (QGeocodeReply::Error)address.county().toInt();
+            errorCode_ = (QGeoCodeReply::Error)address.county().toInt();
         } else {
             errorString_ = "";
-            errorCode_ = QGeocodeReply::NoError;
+            errorCode_ = QGeoCodeReply::NoError;
         }
         // 1. Check if we are to validate values
         if (validateWellKnownValues_) {
             if (address.street() != "wellknown street") {
-                 geocodeReply_->callSetError(QGeocodeReply::EngineNotSetError, address.street());
+                 geocodeReply_->callSetError(QGeoCodeReply::EngineNotSetError, address.street());
             } else {
-                geocodeReply_->callSetError(QGeocodeReply::NoError,address.street());
+                geocodeReply_->callSetError(QGeoCodeReply::NoError,address.street());
             }
         }
 
@@ -177,7 +177,7 @@ public:
             Q_ASSERT(timerId_ == 0);
             timerId_ = startTimer(200);
         }
-        return static_cast<QGeocodeReply*>(geocodeReply_);
+        return static_cast<QGeoCodeReply*>(geocodeReply_);
     }
 
 public Q_SLOTS:
@@ -188,7 +188,7 @@ public Q_SLOTS:
             timerId_ = 0;
         }
         errorString_ = "";
-        errorCode_ = QGeocodeReply::NoError;
+        errorCode_ = QGeoCodeReply::NoError;
     }
 
 public:
@@ -226,7 +226,7 @@ public:
         }
     }
 
-    QGeocodeReply*  reverseGeocode ( const QGeoCoordinate & coordinate, const QGeoShape &bounds )
+    QGeoCodeReply* reverseGeocode(const QGeoCoordinate &coordinate, const QGeoShape &bounds)
     {
         geocodeReply_ = new GeocodeReplyTest();
         connect(geocodeReply_, SIGNAL(aborted()), this, SLOT(requestAborted()));
@@ -236,16 +236,16 @@ public:
 
         if (coordinate.latitude() > 70) {
             errorString_ = "error";
-            errorCode_ = (QGeocodeReply::Error) (qRound(coordinate.latitude() - 70));
+            errorCode_ = (QGeoCodeReply::Error) (qRound(coordinate.latitude() - 70));
         } else {
             errorString_ = "";
-            errorCode_ = QGeocodeReply::NoError;
+            errorCode_ = QGeoCodeReply::NoError;
         }
         if (finishRequestImmediately_) {
             if (errorCode_) {
                 geocodeReply_->callSetError(errorCode_, errorString_);
             } else {
-                geocodeReply_->callSetError(QGeocodeReply::NoError,coordinate.toString());
+                geocodeReply_->callSetError(QGeoCodeReply::NoError,coordinate.toString());
                 geocodeReply_->callSetFinished(true);
             }
         } else {
@@ -253,7 +253,7 @@ public:
             Q_ASSERT(timerId_ == 0);
             timerId_ = startTimer(200);
         }
-        return static_cast<QGeocodeReply*>(geocodeReply_);
+        return static_cast<QGeoCodeReply*>(geocodeReply_);
     }
 
 protected:
@@ -267,7 +267,7 @@ protected:
              geocodeReply_->callSetError(errorCode_, errorString_);
              emit error(geocodeReply_, errorCode_, errorString_);
         } else {
-             geocodeReply_->callSetError(QGeocodeReply::NoError, "no error");
+             geocodeReply_->callSetError(QGeoCodeReply::NoError, "no error");
              geocodeReply_->callSetFinished(true);
          }
          emit finished(geocodeReply_);
@@ -279,7 +279,7 @@ private:
     bool supported_;
     GeocodeReplyTest* geocodeReply_;
     int timerId_;
-    QGeocodeReply::Error errorCode_;
+    QGeoCodeReply::Error errorCode_;
     QString errorString_;
 };
 
diff --git a/tests/auto/geotestplugin/qgeoserviceproviderplugin_test.cpp b/tests/auto/geotestplugin/qgeoserviceproviderplugin_test.cpp
index 5f05937a..b902d75c 100644
--- a/tests/auto/geotestplugin/qgeoserviceproviderplugin_test.cpp
+++ b/tests/auto/geotestplugin/qgeoserviceproviderplugin_test.cpp
@@ -55,24 +55,25 @@ QGeoServiceProviderFactoryTest::~QGeoServiceProviderFactoryTest()
 {
 }
 
-QGeoRoutingManagerEngine* QGeoServiceProviderFactoryTest::createRoutingManagerEngine (
+QGeoRoutingManagerEngine* QGeoServiceProviderFactoryTest::createRoutingManagerEngine(
             const QMap<QString, QVariant> & parameters,
-            QGeoServiceProvider::Error * error, QString * errorString ) const
+            QGeoServiceProvider::Error * error, QString *errorString) const
 {
     return new QGeoRoutingManagerEngineTest(parameters, error, errorString);
 }
 
 
-QGeocodingManagerEngine* QGeoServiceProviderFactoryTest::createGeocodingManagerEngine(const QMap<
-    QString, QVariant> &parameters, QGeoServiceProvider::Error *error, QString *errorString) const
+QGeoCodingManagerEngine* QGeoServiceProviderFactoryTest::createGeocodingManagerEngine(
+                const QMap<QString, QVariant> &parameters, QGeoServiceProvider::Error *error,
+                QString *errorString) const
 {
-    return new QGeocodingManagerEngineTest(parameters, error, errorString);
+    return new QGeoCodingManagerEngineTest(parameters, error, errorString);
 }
 
 
-QGeoMappingManagerEngine* QGeoServiceProviderFactoryTest::createMappingManagerEngine (
-            const QMap<QString, QVariant> & parameters,
-            QGeoServiceProvider::Error * error, QString * errorString ) const
+QGeoMappingManagerEngine* QGeoServiceProviderFactoryTest::createMappingManagerEngine(
+            const QMap<QString, QVariant> &parameters,
+            QGeoServiceProvider::Error *error, QString *errorString) const
 {
     return new QGeoTiledMappingManagerEngineTest(parameters, error, errorString);
 }
diff --git a/tests/auto/geotestplugin/qgeoserviceproviderplugin_test.h b/tests/auto/geotestplugin/qgeoserviceproviderplugin_test.h
index bdcad224..84939133 100644
--- a/tests/auto/geotestplugin/qgeoserviceproviderplugin_test.h
+++ b/tests/auto/geotestplugin/qgeoserviceproviderplugin_test.h
@@ -58,13 +58,13 @@ public:
     QGeoServiceProviderFactoryTest();
     ~QGeoServiceProviderFactoryTest();
 
-    QGeoMappingManagerEngine* createMappingManagerEngine (
-                const QMap<QString, QVariant> & parameters,
-                QGeoServiceProvider::Error * error, QString * errorString ) const;
-    QGeoRoutingManagerEngine* createRoutingManagerEngine (
-                const QMap<QString, QVariant> & parameters,
-                QGeoServiceProvider::Error * error, QString * errorString ) const;
-    QGeocodingManagerEngine* createGeocodingManagerEngine(
+    QGeoMappingManagerEngine* createMappingManagerEngine(
+                const QMap<QString, QVariant> &parameters,
+                QGeoServiceProvider::Error *error, QString *errorString) const;
+    QGeoRoutingManagerEngine* createRoutingManagerEngine(
+                const QMap<QString, QVariant> &parameters,
+                QGeoServiceProvider::Error *error, QString *errorString ) const;
+    QGeoCodingManagerEngine* createGeocodingManagerEngine(
                 const QMap<QString, QVariant> &parameters,
                 QGeoServiceProvider::Error *error, QString *errorString) const;
     QPlaceManagerEngine* createPlaceManagerEngine(
diff --git a/tests/auto/qgeocodereply/tst_qgeocodereply.cpp b/tests/auto/qgeocodereply/tst_qgeocodereply.cpp
index a6f3e2e6..3851077a 100644
--- a/tests/auto/qgeocodereply/tst_qgeocodereply.cpp
+++ b/tests/auto/qgeocodereply/tst_qgeocodereply.cpp
@@ -43,39 +43,39 @@
 
 QT_USE_NAMESPACE
 
-void tst_QGeocodeReply::initTestCase()
+void tst_QGeoCodeReply::initTestCase()
 {
 
     reply = new SubGeocodeReply();
 }
 
-void tst_QGeocodeReply::cleanupTestCase()
+void tst_QGeoCodeReply::cleanupTestCase()
 {
 
     delete reply;
     delete qgeolocation;
 }
 
-void tst_QGeocodeReply::init()
+void tst_QGeoCodeReply::init()
 {
-    qRegisterMetaType<QGeocodeReply::Error>("Error");
-    signalerror = new QSignalSpy(reply, SIGNAL(error(QGeocodeReply::Error,const QString)));
+    qRegisterMetaType<QGeoCodeReply::Error>("Error");
+    signalerror = new QSignalSpy(reply, SIGNAL(error(QGeoCodeReply::Error,const QString)));
     signalfinished = new QSignalSpy(reply, SIGNAL(finished()));
 }
 
-void tst_QGeocodeReply::cleanup()
+void tst_QGeoCodeReply::cleanup()
 {
     delete signalerror;
     delete signalfinished;
 }
 
-void tst_QGeocodeReply::constructor()
+void tst_QGeoCodeReply::constructor()
 {
     QVERIFY(!reply->isFinished());
 
     QCOMPARE(reply->limit(),-1);
     QCOMPARE(reply->offset(),0);
-    QCOMPARE(reply->error(),QGeocodeReply::NoError);
+    QCOMPARE(reply->error(),QGeoCodeReply::NoError);
 
     QVERIFY( signalerror->isValid() );
     QVERIFY( signalfinished->isValid() );
@@ -84,15 +84,15 @@ void tst_QGeocodeReply::constructor()
     QCOMPARE(signalfinished->count(),0);
 }
 
-void tst_QGeocodeReply::constructor_error()
+void tst_QGeoCodeReply::constructor_error()
 {
-    QFETCH(QGeocodeReply::Error,error);
+    QFETCH(QGeoCodeReply::Error,error);
     QFETCH(QString,msg);
 
     QVERIFY( signalerror->isValid() );
     QVERIFY( signalfinished->isValid() );
 
-    QGeocodeReply *qgeocodereplycopy = new QGeocodeReply (error,msg,0);
+    QGeoCodeReply *qgeocodereplycopy = new QGeoCodeReply (error,msg,0);
 
     QCOMPARE(signalerror->count(),0);
     QCOMPARE(signalfinished->count(),0);
@@ -103,36 +103,36 @@ void tst_QGeocodeReply::constructor_error()
     delete qgeocodereplycopy;
 }
 
-void tst_QGeocodeReply::constructor_error_data()
+void tst_QGeoCodeReply::constructor_error_data()
 {
-    QTest::addColumn<QGeocodeReply::Error>("error");
+    QTest::addColumn<QGeoCodeReply::Error>("error");
     QTest::addColumn<QString>("msg");
 
-    QTest::newRow("error1") << QGeocodeReply::NoError << "No error.";
-    QTest::newRow("error2") << QGeocodeReply::EngineNotSetError << "Engine Not Set Error.";
-    QTest::newRow("error3") << QGeocodeReply::CommunicationError << "Communication Error.";
-    QTest::newRow("error4") << QGeocodeReply::ParseError << "Parse Error.";
-    QTest::newRow("error5") << QGeocodeReply::UnsupportedOptionError << "Unsupported Option Error.";
-    QTest::newRow("error6") << QGeocodeReply::UnknownError << "Unknown Error.";
+    QTest::newRow("error1") << QGeoCodeReply::NoError << "No error.";
+    QTest::newRow("error2") << QGeoCodeReply::EngineNotSetError << "Engine Not Set Error.";
+    QTest::newRow("error3") << QGeoCodeReply::CommunicationError << "Communication Error.";
+    QTest::newRow("error4") << QGeoCodeReply::ParseError << "Parse Error.";
+    QTest::newRow("error5") << QGeoCodeReply::UnsupportedOptionError << "Unsupported Option Error.";
+    QTest::newRow("error6") << QGeoCodeReply::UnknownError << "Unknown Error.";
 
 }
 
-void tst_QGeocodeReply::destructor()
+void tst_QGeoCodeReply::destructor()
 {
-    QGeocodeReply *qgeocodereplycopy;
-    QFETCH(QGeocodeReply::Error,error);
+    QGeoCodeReply *qgeocodereplycopy;
+    QFETCH(QGeoCodeReply::Error,error);
     QFETCH(QString,msg);
 
-    qgeocodereplycopy = new QGeocodeReply (error,msg,0);
+    qgeocodereplycopy = new QGeoCodeReply (error,msg,0);
     delete qgeocodereplycopy;
 }
 
-void tst_QGeocodeReply::destructor_data()
+void tst_QGeoCodeReply::destructor_data()
 {
-    tst_QGeocodeReply::constructor_error_data();
+    tst_QGeoCodeReply::constructor_error_data();
 }
 
-void tst_QGeocodeReply::abort()
+void tst_QGeoCodeReply::abort()
 {
     QVERIFY( signalerror->isValid() );
     QVERIFY( signalfinished->isValid() );
@@ -154,9 +154,9 @@ void tst_QGeocodeReply::abort()
     QCOMPARE (signalfinished->count(),2);
 }
 
-void tst_QGeocodeReply::error()
+void tst_QGeoCodeReply::error()
 {
-    QFETCH(QGeocodeReply::Error,error);
+    QFETCH(QGeoCodeReply::Error,error);
     QFETCH(QString,msg);
 
     QVERIFY( signalerror->isValid() );
@@ -173,20 +173,20 @@ void tst_QGeocodeReply::error()
 
 }
 
-void tst_QGeocodeReply::error_data()
+void tst_QGeoCodeReply::error_data()
 {
-    QTest::addColumn<QGeocodeReply::Error>("error");
+    QTest::addColumn<QGeoCodeReply::Error>("error");
     QTest::addColumn<QString>("msg");
 
-    QTest::newRow("error1") << QGeocodeReply::NoError << "No error.";
-    QTest::newRow("error2") << QGeocodeReply::EngineNotSetError << "Engine Not Set Error.";
-    QTest::newRow("error3") << QGeocodeReply::CommunicationError << "Communication Error.";
-    QTest::newRow("error4") << QGeocodeReply::ParseError << "Parse Error.";
-    QTest::newRow("error5") << QGeocodeReply::UnsupportedOptionError << "Unsupported Option Error.";
-    QTest::newRow("error6") << QGeocodeReply::UnknownError << "Unknown Error.";
+    QTest::newRow("error1") << QGeoCodeReply::NoError << "No error.";
+    QTest::newRow("error2") << QGeoCodeReply::EngineNotSetError << "Engine Not Set Error.";
+    QTest::newRow("error3") << QGeoCodeReply::CommunicationError << "Communication Error.";
+    QTest::newRow("error4") << QGeoCodeReply::ParseError << "Parse Error.";
+    QTest::newRow("error5") << QGeoCodeReply::UnsupportedOptionError << "Unsupported Option Error.";
+    QTest::newRow("error6") << QGeoCodeReply::UnknownError << "Unknown Error.";
 }
 
-void tst_QGeocodeReply::finished()
+void tst_QGeoCodeReply::finished()
 {
     QVERIFY( signalerror->isValid() );
     QVERIFY( signalfinished->isValid() );
@@ -214,21 +214,21 @@ void tst_QGeocodeReply::finished()
 
 
 
-void tst_QGeocodeReply::limit()
+void tst_QGeoCodeReply::limit()
 {
     int limit =30;
     reply->callSetLimit(limit);
     QCOMPARE(reply->limit(),limit);
 }
 
-void tst_QGeocodeReply::offset()
+void tst_QGeoCodeReply::offset()
 {
     int offset = 2;
     reply->callSetOffset(offset);
     QCOMPARE(reply->offset(),offset);
 }
 
-void tst_QGeocodeReply::locations()
+void tst_QGeoCodeReply::locations()
 {
     QList <QGeoLocation> geolocations;
     geolocations = reply->locations();
@@ -271,7 +271,7 @@ void tst_QGeocodeReply::locations()
     delete qgeolocationcopy;
 }
 
-void tst_QGeocodeReply::viewport()
+void tst_QGeoCodeReply::viewport()
 {
     QGeoCoordinate *qgeocoordinate = new QGeoCoordinate (12.12 , 54.43);
 
@@ -285,4 +285,4 @@ void tst_QGeocodeReply::viewport()
     delete qgeoboundingbox;
 }
 
-QTEST_MAIN(tst_QGeocodeReply);
+QTEST_MAIN(tst_QGeoCodeReply);
diff --git a/tests/auto/qgeocodereply/tst_qgeocodereply.h b/tests/auto/qgeocodereply/tst_qgeocodereply.h
index 62286e91..b830112d 100644
--- a/tests/auto/qgeocodereply/tst_qgeocodereply.h
+++ b/tests/auto/qgeocodereply/tst_qgeocodereply.h
@@ -57,11 +57,11 @@
 #include <QtPositioning/QGeoRectangle>
 
 QT_USE_NAMESPACE
-class SubGeocodeReply : public QGeocodeReply
+class SubGeocodeReply : public QGeoCodeReply
 {
     Q_OBJECT
 public:
-    SubGeocodeReply():QGeocodeReply() {}
+    SubGeocodeReply() : QGeoCodeReply() {}
 
     void  callAddLocation ( const QGeoLocation & location ) {addLocation(location);}
     void  callSetError ( Error error, const QString & errorString ) {setError(error, errorString);}
@@ -73,7 +73,7 @@ public:
 
 };
 
-class tst_QGeocodeReply :public QObject
+class tst_QGeoCodeReply :public QObject
 {
     Q_OBJECT
 
@@ -111,8 +111,8 @@ private:
     QGeoRectangle *qgeoboundingbox;
 };
 
-Q_DECLARE_METATYPE( QList<double>);
-Q_DECLARE_METATYPE( QGeocodeReply::Error);
+Q_DECLARE_METATYPE(QList<double>);
+Q_DECLARE_METATYPE(QGeoCodeReply::Error);
 
 #endif // TST_QGEOCODEREPLY_H
 
diff --git a/tests/auto/qgeocodingmanager/tst_qgeocodingmanager.cpp b/tests/auto/qgeocodingmanager/tst_qgeocodingmanager.cpp
index 0cc9d329..d3f183b7 100644
--- a/tests/auto/qgeocodingmanager/tst_qgeocodingmanager.cpp
+++ b/tests/auto/qgeocodingmanager/tst_qgeocodingmanager.cpp
@@ -46,39 +46,39 @@
 QT_USE_NAMESPACE
 
 
-void tst_QGeocodingManager::initTestCase()
+void tst_QGeoCodingManager::initTestCase()
 {
     /*
      * Set custom path since CI doesn't install test plugins
      */
     QCoreApplication::addLibraryPath(QCoreApplication::applicationDirPath()
                                      + QStringLiteral("/../../../plugins"));
-    tst_QGeocodingManager::loadGeocodingManager();
+    tst_QGeoCodingManager::loadGeocodingManager();
 }
 
-void tst_QGeocodingManager::cleanupTestCase()
+void tst_QGeoCodingManager::cleanupTestCase()
 {
     delete qgeoserviceprovider;
 }
 
-void tst_QGeocodingManager::init()
+void tst_QGeoCodingManager::init()
 {
-    qRegisterMetaType<QGeocodeReply::Error>("Error");
-    qRegisterMetaType<QGeocodeReply*>();
+    qRegisterMetaType<QGeoCodeReply::Error>("Error");
+    qRegisterMetaType<QGeoCodeReply*>();
 
-    signalerror = new QSignalSpy(qgeocodingmanager, SIGNAL(error(QGeocodeReply*,QGeocodeReply::Error,QString)));
-    signalfinished = new QSignalSpy(qgeocodingmanager, SIGNAL(finished(QGeocodeReply*)));
+    signalerror = new QSignalSpy(qgeocodingmanager, SIGNAL(error(QGeoCodeReply*,QGeoCodeReply::Error,QString)));
+    signalfinished = new QSignalSpy(qgeocodingmanager, SIGNAL(finished(QGeoCodeReply*)));
     QVERIFY( signalerror->isValid() );
     QVERIFY( signalfinished->isValid() );
 }
 
-void tst_QGeocodingManager::cleanup()
+void tst_QGeoCodingManager::cleanup()
 {
     delete signalerror;
     delete signalfinished;
 }
 
-void tst_QGeocodingManager::loadGeocodingManager()
+void tst_QGeoCodingManager::loadGeocodingManager()
 {
     QStringList providers = QGeoServiceProvider::availableServiceProviders();
     QVERIFY(providers.contains("geocode.test.plugin"));
@@ -97,7 +97,7 @@ void tst_QGeocodingManager::loadGeocodingManager()
     QVERIFY(qgeocodingmanager);
 }
 
-void tst_QGeocodingManager::locale()
+void tst_QGeoCodingManager::locale()
 {
     QLocale *german = new QLocale (QLocale::German, QLocale::Germany);
     QLocale *english = new QLocale (QLocale::C, QLocale::AnyCountry);
@@ -115,20 +115,20 @@ void tst_QGeocodingManager::locale()
     delete english;
 }
 
-void tst_QGeocodingManager::name()
+void tst_QGeoCodingManager::name()
 {
     QString name = "geocode.test.plugin";
     QCOMPARE(qgeocodingmanager->managerName(),name);
 }
 
-void tst_QGeocodingManager::version()
+void tst_QGeoCodingManager::version()
 {
     int version=100;
     QCOMPARE(qgeocodingmanager->managerVersion(),version);
 
 }
 
-void tst_QGeocodingManager::search()
+void tst_QGeoCodingManager::search()
 {
     QCOMPARE(signalerror->count(),0);
     QCOMPARE(signalfinished->count(),0);
@@ -137,7 +137,7 @@ void tst_QGeocodingManager::search()
     int limit = 10;
     int offset = 2;
 
-    QGeocodeReply * reply = qgeocodingmanager->geocode(search, limit,offset);
+    QGeoCodeReply * reply = qgeocodingmanager->geocode(search, limit,offset);
 
     QCOMPARE(reply->errorString(),search);
     QCOMPARE(signalfinished->count(),1);
@@ -146,7 +146,7 @@ void tst_QGeocodingManager::search()
     delete reply;
 }
 
-void tst_QGeocodingManager::geocode()
+void tst_QGeoCodingManager::geocode()
 {
     QCOMPARE(signalerror->count(),0);
     QCOMPARE(signalfinished->count(),0);
@@ -155,7 +155,7 @@ void tst_QGeocodingManager::geocode()
     QString city = "Berlin";
     address->setCity(city);
 
-    QGeocodeReply *reply = qgeocodingmanager->geocode(*address);
+    QGeoCodeReply *reply = qgeocodingmanager->geocode(*address);
 
     QCOMPARE(reply->errorString(),city);
     QCOMPARE(signalfinished->count(),1);
@@ -165,18 +165,18 @@ void tst_QGeocodingManager::geocode()
     delete reply;
 }
 
-void tst_QGeocodingManager::reverseGeocode()
+void tst_QGeoCodingManager::reverseGeocode()
 {
-    QCOMPARE(signalerror->count(),0);
-    QCOMPARE(signalfinished->count(),0);
+    QCOMPARE(signalerror->count(), 0);
+    QCOMPARE(signalfinished->count(), 0);
 
-    QGeoCoordinate *coordinate = new QGeoCoordinate (34.34 , 56.65);
+    QGeoCoordinate *coordinate = new QGeoCoordinate(34.34, 56.65);
 
-    QGeocodeReply *reply = qgeocodingmanager->reverseGeocode(*coordinate);
+    QGeoCodeReply *reply = qgeocodingmanager->reverseGeocode(*coordinate);
 
-    QCOMPARE(reply->errorString(),coordinate->toString());
-    QCOMPARE(signalfinished->count(),1);
-    QCOMPARE(signalerror->count(),0);
+    QCOMPARE(reply->errorString(), coordinate->toString());
+    QCOMPARE(signalfinished->count(), 1);
+    QCOMPARE(signalerror->count(), 0);
 
     delete coordinate;
     delete reply;
@@ -185,5 +185,5 @@ void tst_QGeocodingManager::reverseGeocode()
 }
 
 
-QTEST_GUILESS_MAIN(tst_QGeocodingManager)
+QTEST_GUILESS_MAIN(tst_QGeoCodingManager)
 
diff --git a/tests/auto/qgeocodingmanager/tst_qgeocodingmanager.h b/tests/auto/qgeocodingmanager/tst_qgeocodingmanager.h
index 065d5134..8a0ee146 100644
--- a/tests/auto/qgeocodingmanager/tst_qgeocodingmanager.h
+++ b/tests/auto/qgeocodingmanager/tst_qgeocodingmanager.h
@@ -58,7 +58,7 @@
 
 QT_USE_NAMESPACE
 
-class tst_QGeocodingManager: public QObject
+class tst_QGeoCodingManager: public QObject
 {
     Q_OBJECT
 
@@ -76,14 +76,14 @@ private Q_SLOTS:
 
 private:
     QGeoServiceProvider *qgeoserviceprovider;
-    QGeocodingManager *qgeocodingmanager;
+    QGeoCodingManager *qgeocodingmanager;
     QSignalSpy *signalerror;
     QSignalSpy *signalfinished;
     void loadGeocodingManager();
 
 };
-Q_DECLARE_METATYPE( QGeocodeReply*);
-Q_DECLARE_METATYPE( QGeocodeReply::Error);
+Q_DECLARE_METATYPE(QGeoCodeReply*);
+Q_DECLARE_METATYPE(QGeoCodeReply::Error);
 
 #endif
 
diff --git a/tests/auto/qgeocodingmanagerplugins/qgeocodingmanagerengine_test.h b/tests/auto/qgeocodingmanagerplugins/qgeocodingmanagerengine_test.h
index 49ce3215..c1c17b1b 100644
--- a/tests/auto/qgeocodingmanagerplugins/qgeocodingmanagerengine_test.h
+++ b/tests/auto/qgeocodingmanagerplugins/qgeocodingmanagerengine_test.h
@@ -52,11 +52,11 @@
 
 QT_USE_NAMESPACE
 
-class GeocodeReplyTest :public QGeocodeReply
+class GeocodeReplyTest : public QGeoCodeReply
 {
     Q_OBJECT
 public:
-    GeocodeReplyTest(QObject *parent=0):QGeocodeReply (parent) {}
+    GeocodeReplyTest(QObject *parent = 0) : QGeoCodeReply(parent) {}
 
     void  callAddLocation ( const QGeoLocation & location ) {addLocation(location);}
     void  callSetError ( Error error, const QString & errorString ) {setError(error, errorString);}
@@ -68,52 +68,52 @@ public:
 
 };
 
-class QGeocodingManagerEngineTest: public QGeocodingManagerEngine
+class QGeoCodingManagerEngineTest: public QGeoCodingManagerEngine
 
 {
 Q_OBJECT
 public:
-    QGeocodingManagerEngineTest(const QMap<QString, QVariant> &parameters,
-        QGeoServiceProvider::Error *error, QString *errorString) :
-        QGeocodingManagerEngine(parameters)
+    QGeoCodingManagerEngineTest(const QMap<QString, QVariant> &parameters,
+                                QGeoServiceProvider::Error *error, QString *errorString) :
+                                QGeoCodingManagerEngine(parameters)
     {
         Q_UNUSED(error)
         Q_UNUSED(errorString)
         setLocale(QLocale(QLocale::German, QLocale::Germany));
     }
 
-    QGeocodeReply*  geocode ( const QString & searchString, int limit, int offset, const QGeoShape &bounds )
+    QGeoCodeReply* geocode(const QString &searchString, int limit, int offset, const QGeoShape &bounds)
     {
         GeocodeReplyTest *geocodereply = new GeocodeReplyTest();
         geocodereply->callSetLimit(limit);
         geocodereply->callSetOffset(offset);
         geocodereply->callSetViewport(bounds);
-        geocodereply->callSetError(QGeocodeReply::NoError,searchString);
+        geocodereply->callSetError(QGeoCodeReply::NoError,searchString);
         geocodereply->callSetFinished(true);
         emit(this->finished(geocodereply));
 
-        return static_cast<QGeocodeReply*>(geocodereply);
+        return static_cast<QGeoCodeReply*>(geocodereply);
     }
 
-    QGeocodeReply*  geocode ( const QGeoAddress & address, const QGeoShape &bounds )
+    QGeoCodeReply* geocode (const QGeoAddress &address, const QGeoShape &bounds)
     {
         GeocodeReplyTest *geocodereply = new GeocodeReplyTest();
         geocodereply->callSetViewport(bounds);
-        geocodereply->callSetError(QGeocodeReply::NoError,address.city());
+        geocodereply->callSetError(QGeoCodeReply::NoError,address.city());
         geocodereply->callSetFinished(true);
         emit(this->finished(geocodereply));
 
-        return static_cast<QGeocodeReply*>(geocodereply);
+        return static_cast<QGeoCodeReply*>(geocodereply);
     }
 
-    QGeocodeReply*  reverseGeocode ( const QGeoCoordinate & coordinate, const QGeoShape &bounds )
+    QGeoCodeReply* reverseGeocode(const QGeoCoordinate &coordinate, const QGeoShape &bounds)
     {
         GeocodeReplyTest *geocodereply = new GeocodeReplyTest();
         geocodereply->callSetViewport(bounds);
-        geocodereply->callSetError(QGeocodeReply::NoError,coordinate.toString());
+        geocodereply->callSetError(QGeoCodeReply::NoError,coordinate.toString());
         geocodereply->callSetFinished(true);
         emit(this->finished(geocodereply));
-        return static_cast<QGeocodeReply*>(geocodereply);
+        return static_cast<QGeoCodeReply*>(geocodereply);
     }
 };
 
diff --git a/tests/auto/qgeocodingmanagerplugins/qgeoserviceproviderplugin_test.cpp b/tests/auto/qgeocodingmanagerplugins/qgeoserviceproviderplugin_test.cpp
index 218cc906..d16ba32e 100644
--- a/tests/auto/qgeocodingmanagerplugins/qgeoserviceproviderplugin_test.cpp
+++ b/tests/auto/qgeocodingmanagerplugins/qgeoserviceproviderplugin_test.cpp
@@ -52,8 +52,9 @@ QGeoServiceProviderFactoryTest::~QGeoServiceProviderFactoryTest()
 {
 }
 
-QGeocodingManagerEngine* QGeoServiceProviderFactoryTest::createGeocodingManagerEngine(const QMap<
-    QString, QVariant> &parameters, QGeoServiceProvider::Error *error, QString *errorString) const
+QGeoCodingManagerEngine* QGeoServiceProviderFactoryTest::createGeocodingManagerEngine(
+                const QMap<QString, QVariant> &parameters, QGeoServiceProvider::Error *error,
+                QString *errorString) const
 {
-    return new QGeocodingManagerEngineTest(parameters, error, errorString);
+    return new QGeoCodingManagerEngineTest(parameters, error, errorString);
 }
diff --git a/tests/auto/qgeocodingmanagerplugins/qgeoserviceproviderplugin_test.h b/tests/auto/qgeocodingmanagerplugins/qgeoserviceproviderplugin_test.h
index ecb59cc7..c49e90bb 100644
--- a/tests/auto/qgeocodingmanagerplugins/qgeoserviceproviderplugin_test.h
+++ b/tests/auto/qgeocodingmanagerplugins/qgeoserviceproviderplugin_test.h
@@ -58,8 +58,9 @@ public:
     QGeoServiceProviderFactoryTest();
     ~QGeoServiceProviderFactoryTest();
 
-    QGeocodingManagerEngine* createGeocodingManagerEngine(const QMap<QString, QVariant> &parameters,
-        QGeoServiceProvider::Error *error, QString *errorString) const;
+    QGeoCodingManagerEngine* createGeocodingManagerEngine(
+                const QMap<QString, QVariant> &parameters,
+                QGeoServiceProvider::Error *error, QString *errorString) const;
 };
 
 #endif
diff --git a/tests/auto/qproposedsearchresult/tst_qproposedsearchresult.cpp b/tests/auto/qproposedsearchresult/tst_qproposedsearchresult.cpp
index 71ba06de..82e6df46 100644
--- a/tests/auto/qproposedsearchresult/tst_qproposedsearchresult.cpp
+++ b/tests/auto/qproposedsearchresult/tst_qproposedsearchresult.cpp
@@ -40,7 +40,7 @@
 ****************************************************************************/
 
 #include <QtCore/QString>
-#include <QtLocation/QProposedSearchResult>
+#include <QtLocation/QPlaceProposedSearchResult>
 #include <QtLocation/QPlaceIcon>
 #include <QtLocation/QPlaceSearchRequest>
 #include <QtTest/QtTest>
@@ -49,15 +49,15 @@
 
 QT_USE_NAMESPACE
 
-class tst_QProposedSearchResult : public QObject
+class tst_QPlaceProposedSearchResult : public QObject
 {
     Q_OBJECT
 
 public:
-    QProposedSearchResult initialSubObject();
+    QPlaceProposedSearchResult initialSubObject();
     bool checkType(const QPlaceSearchResult &result);
     void detach(QPlaceSearchResult *result);
-    void setSubClassProperty(QProposedSearchResult *result);
+    void setSubClassProperty(QPlaceProposedSearchResult *result);
 
 private Q_SLOTS:
     void constructorTest();
@@ -67,9 +67,9 @@ private Q_SLOTS:
     void conversion();
 };
 
-QProposedSearchResult tst_QProposedSearchResult::initialSubObject()
+QPlaceProposedSearchResult tst_QPlaceProposedSearchResult::initialSubObject()
 {
-    QProposedSearchResult proposedSearchResult;
+    QPlaceProposedSearchResult proposedSearchResult;
     proposedSearchResult.setTitle(QStringLiteral("title"));
 
     QPlaceIcon icon;
@@ -86,26 +86,26 @@ QProposedSearchResult tst_QProposedSearchResult::initialSubObject()
     return proposedSearchResult;
 }
 
-bool tst_QProposedSearchResult::checkType(const QPlaceSearchResult &result)
+bool tst_QPlaceProposedSearchResult::checkType(const QPlaceSearchResult &result)
 {
     return result.type() == QPlaceSearchResult::ProposedSearchResult;
 }
 
-void tst_QProposedSearchResult::detach(QPlaceSearchResult *result)
+void tst_QPlaceProposedSearchResult::detach(QPlaceSearchResult *result)
 {
     result->setTitle(QStringLiteral("title"));
 }
 
-void tst_QProposedSearchResult::setSubClassProperty(QProposedSearchResult *result)
+void tst_QPlaceProposedSearchResult::setSubClassProperty(QPlaceProposedSearchResult *result)
 {
     QPlaceSearchRequest request;
     request.setSearchContext(QUrl(QStringLiteral("http://www.example.com/place-search")));
     result->setSearchRequest(request);
 }
 
-void tst_QProposedSearchResult::constructorTest()
+void tst_QPlaceProposedSearchResult::constructorTest()
 {
-    QProposedSearchResult result;
+    QPlaceProposedSearchResult result;
     QCOMPARE(result.type(), QPlaceSearchResult::ProposedSearchResult);
 
     result.setTitle(QStringLiteral("title"));
@@ -121,7 +121,7 @@ void tst_QProposedSearchResult::constructorTest()
     result.setSearchRequest(searchRequest);
 
     //check copy constructor
-    QProposedSearchResult result2(result);
+    QPlaceProposedSearchResult result2(result);
     QCOMPARE(result2.title(), QStringLiteral("title"));
     QCOMPARE(result2.icon(), icon);
     QCOMPARE(result2.searchRequest(), searchRequest);
@@ -153,9 +153,9 @@ void tst_QProposedSearchResult::constructorTest()
     QVERIFY(QLocationTestUtils::compareEquality(result, result2));
 }
 
-void tst_QProposedSearchResult::title()
+void tst_QPlaceProposedSearchResult::title()
 {
-    QProposedSearchResult result;
+    QPlaceProposedSearchResult result;
     QVERIFY(result.title().isEmpty());
 
     result.setTitle(QStringLiteral("title"));
@@ -164,7 +164,7 @@ void tst_QProposedSearchResult::title()
     result.setTitle(QString());
     QVERIFY(result.title().isEmpty());
 
-    QProposedSearchResult result2;
+    QPlaceProposedSearchResult result2;
     QVERIFY(QLocationTestUtils::compareEquality(result, result2));
 
     result2.setTitle("title");
@@ -174,9 +174,9 @@ void tst_QProposedSearchResult::title()
     QVERIFY(QLocationTestUtils::compareEquality(result, result2));
 }
 
-void tst_QProposedSearchResult::icon()
+void tst_QPlaceProposedSearchResult::icon()
 {
-    QProposedSearchResult result;
+    QPlaceProposedSearchResult result;
     QVERIFY(result.icon().isEmpty());
 
     QPlaceIcon icon;
@@ -189,7 +189,7 @@ void tst_QProposedSearchResult::icon()
     result.setIcon(QPlaceIcon());
     QVERIFY(result.icon().isEmpty());
 
-    QProposedSearchResult result2;
+    QPlaceProposedSearchResult result2;
     QVERIFY(QLocationTestUtils::compareEquality(result, result2));
 
     result2.setIcon(icon);
@@ -199,9 +199,9 @@ void tst_QProposedSearchResult::icon()
     QVERIFY(QLocationTestUtils::compareEquality(result, result2));
 }
 
-void tst_QProposedSearchResult::searchRequest()
+void tst_QPlaceProposedSearchResult::searchRequest()
 {
-    QProposedSearchResult result;
+    QPlaceProposedSearchResult result;
     QCOMPARE(result.searchRequest(), QPlaceSearchRequest());
 
     QPlaceSearchRequest placeSearchRequest;
@@ -212,7 +212,7 @@ void tst_QProposedSearchResult::searchRequest()
     result.setSearchRequest(QPlaceSearchRequest());
     QCOMPARE(result.searchRequest(), QPlaceSearchRequest());
 
-    QProposedSearchResult result2;
+    QPlaceProposedSearchResult result2;
     QVERIFY(QLocationTestUtils::compareEquality(result, result2));
 
     result2.setSearchRequest(placeSearchRequest);
@@ -222,13 +222,13 @@ void tst_QProposedSearchResult::searchRequest()
     QVERIFY(QLocationTestUtils::compareEquality(result, result2));
 }
 
-void tst_QProposedSearchResult::conversion()
+void tst_QPlaceProposedSearchResult::conversion()
 {
-    QLocationTestUtils::testConversion<tst_QProposedSearchResult,
+    QLocationTestUtils::testConversion<tst_QPlaceProposedSearchResult,
                                        QPlaceSearchResult,
-                                       QProposedSearchResult>(this);
+                                       QPlaceProposedSearchResult>(this);
 }
 
-QTEST_APPLESS_MAIN(tst_QProposedSearchResult)
+QTEST_APPLESS_MAIN(tst_QPlaceProposedSearchResult)
 
 #include "tst_qproposedsearchresult.moc"