Rename settings in config.xml file

Rename UninstallerName to MaintenanceToolName
(change its default value to "maintenancetool").
Rename UninstallerIniFile to MaintenanceToolIniFile.

Change-Id: Ic8ceae80b43c6793ae9b0baacea2ea374a0f90d1
Reviewed-by: Niels Weber <niels.weber@digia.com>
Reviewed-by: Karsten Heimrich <karsten.heimrich@digia.com>
Reviewed-by: Kai Koehne <kai.koehne@digia.com>

13 files changed, 110 insertions, 107 deletions

diff --git a/Changelog b/Changelog
index 2b87cdbe0..021e0763b 100644
--- a/Changelog
+++ b/Changelog
@@ -16,6 +16,9 @@
 - Improved documentation.
 - Documentation fixes
 - Only support Qt 5 on documentation side as well.
+- Renamed settings inside config.xml:
+  - UninstallerName renamed to MaintenanceToolName (default value changed to "maintenancetool")
+  - UninstallerIniFile renamed to MaintenanceToolIniFile
 
 Thanks go to Sze Howe Koh, Ray Donnelly and Sascha Cunz for contributions.
 
diff --git a/doc/installerfw.qdoc b/doc/installerfw.qdoc
index 486b69c99..9842c7eb8 100644
--- a/doc/installerfw.qdoc
+++ b/doc/installerfw.qdoc
@@ -239,14 +239,14 @@
                 sections that each specify the \c Url to access the repository.
                 For more information, see \l{Configuring Repositories}.
         \row
-            \li UninstallerName
-            \li Filename of the generated uninstaller. Defaults to
-                \e uninstall. The platform-specific executable file extension is
+            \li MaintenanceToolName
+            \li Filename of the generated maintenance tool. Defaults to
+                \e maintenancetool. The platform-specific executable file extension is
                 appended.
         \row
-            \li UninstallerIniFile
-            \li Filename for the configuration of the generated uninstaller. Defaults to
-                \e {UninstallerName}.ini.
+            \li MaintenanceToolIniFile
+            \li Filename for the configuration of the generated maintenance tool. Defaults to
+                \e {MaintenanceToolName}.ini.
         \row
             \li RemoveTargetDir
             \li Set to \c false if the target directory should not be deleted when uninstalling.
diff --git a/src/libs/installer/packagemanagercore.cpp b/src/libs/installer/packagemanagercore.cpp
index 424ce0c09..5ae2c80ee 100644
--- a/src/libs/installer/packagemanagercore.cpp
+++ b/src/libs/installer/packagemanagercore.cpp
@@ -409,11 +409,11 @@ Component *PackageManagerCore::subComponentByName(const QInstaller::PackageManag
     return 0;
 }
 
-void PackageManagerCore::writeUninstaller()
+void PackageManagerCore::writeMaintenanceTool()
 {
-    if (d->m_needToWriteUninstaller) {
+    if (d->m_needToWriteMaintenanceTool) {
         try {
-            d->writeUninstaller(d->m_performedOperationsOld + d->m_performedOperationsCurrentSession);
+            d->writeMaintenanceTool(d->m_performedOperationsOld + d->m_performedOperationsCurrentSession);
 
             bool gainedAdminRights = false;
             QTemporaryFile tempAdminFile(d->targetDir()
@@ -425,10 +425,10 @@ void PackageManagerCore::writeUninstaller()
             d->m_updaterApplication.packagesInfo()->writeToDisk();
             if (gainedAdminRights)
                 dropAdminRights();
-            d->m_needToWriteUninstaller = false;
+            d->m_needToWriteMaintenanceTool = false;
         } catch (const Error &error) {
             MessageBoxHandler::critical(MessageBoxHandler::currentBestSuitParent(),
-                QLatin1String("WriteError"), tr("Error writing Uninstaller"), error.message(),
+                QLatin1String("WriteError"), tr("Error writing Maintenance Tool"), error.message(),
                 QMessageBox::Ok, QMessageBox::Ok);
         }
     }
@@ -1768,7 +1768,7 @@ QString PackageManagerCore::findPath(const QString &name, const QStringList &pat
 /*!
     \qmlmethod void QInstaller::setInstallerBaseBinary(string path)
 
-    Sets the "installerbase" binary to use when writing the package manager/uninstaller.
+    Sets the "installerbase" binary to use when writing the maintenance tool.
     Set this if an update to installerbase is available.
 
     If not set, the executable segment of the running un/installer will be used.
@@ -1869,7 +1869,7 @@ QString PackageManagerCore::error() const
 */
 bool PackageManagerCore::finishedWithSuccess() const
 {
-    return d->m_status == PackageManagerCore::Success || d->m_needToWriteUninstaller;
+    return d->m_status == PackageManagerCore::Success || d->m_needToWriteMaintenanceTool;
 }
 
 /*!
@@ -2083,11 +2083,11 @@ bool PackageManagerCore::run()
 }
 
 /*!
-    Returns the path name of the uninstaller binary.
+    Returns the path name of the maintenance tool binary.
 */
-QString PackageManagerCore::uninstallerName() const
+QString PackageManagerCore::maintenanceToolName() const
 {
-    return d->uninstallerName();
+    return d->maintenanceToolName();
 }
 
 bool PackageManagerCore::updateComponentData(struct Data &data, Component *component)
diff --git a/src/libs/installer/packagemanagercore.h b/src/libs/installer/packagemanagercore.h
index 737d09242..b3c5013cc 100644
--- a/src/libs/installer/packagemanagercore.h
+++ b/src/libs/installer/packagemanagercore.h
@@ -161,10 +161,10 @@ public:
     QByteArray replaceVariables(const QByteArray &str) const;
     QStringList replaceVariables(const QStringList &str) const;
 
-    void writeUninstaller();
+    void writeMaintenanceTool();
     void writeMaintenanceConfigFiles();
 
-    QString uninstallerName() const;
+    QString maintenanceToolName() const;
     QString installerBinaryPath() const;
 
     bool testChecksum() const;
diff --git a/src/libs/installer/packagemanagercore_p.cpp b/src/libs/installer/packagemanagercore_p.cpp
index 190742d9c..13ed2968c 100644
--- a/src/libs/installer/packagemanagercore_p.cpp
+++ b/src/libs/installer/packagemanagercore_p.cpp
@@ -210,7 +210,7 @@ PackageManagerCorePrivate::PackageManagerCorePrivate(PackageManagerCore *core, q
     , m_testChecksum(false)
     , m_launchedAsRoot(AdminAuthorization::hasAdminRights())
     , m_completeUninstall(false)
-    , m_needToWriteUninstaller(false)
+    , m_needToWriteMaintenanceTool(false)
     , m_performedOperationsOld(performedOperations)
     , m_dependsOnLocalInstallerBinary(false)
     , m_core(core)
@@ -733,9 +733,9 @@ Operation *PackageManagerCorePrivate::takeOwnedOperation(Operation *operation)
     return operation;
 }
 
-QString PackageManagerCorePrivate::uninstallerName() const
+QString PackageManagerCorePrivate::maintenanceToolName() const
 {
-    QString filename = m_data.settings().uninstallerName();
+    QString filename = m_data.settings().maintenanceToolName();
 #if defined(Q_OS_OSX)
     if (QInstaller::isInBundle(QCoreApplication::applicationDirPath()))
         filename += QLatin1String(".app/Contents/MacOS/") + filename;
@@ -793,8 +793,8 @@ static QSet<Repository> readRepositories(QXmlStreamReader &reader, bool isDefaul
 
 void PackageManagerCorePrivate::writeMaintenanceConfigFiles()
 {
-    // write current state (variables) to the uninstaller ini file
-    const QString iniPath = targetDir() + QLatin1Char('/') + m_data.settings().uninstallerIniFile();
+    // write current state (variables) to the maintenance tool ini file
+    const QString iniPath = targetDir() + QLatin1Char('/') + m_data.settings().maintenanceToolIniFile();
 
     QVariantHash variables;
     QSettingsWrapper cfg(iniPath, QSettingsWrapper::IniFormat);
@@ -856,7 +856,7 @@ void PackageManagerCorePrivate::writeMaintenanceConfigFiles()
 
 void PackageManagerCorePrivate::readMaintenanceConfigFiles(const QString &targetDir)
 {
-    QSettingsWrapper cfg(targetDir + QLatin1Char('/') + m_data.settings().uninstallerIniFile(),
+    QSettingsWrapper cfg(targetDir + QLatin1Char('/') + m_data.settings().maintenanceToolIniFile(),
         QSettingsWrapper::IniFormat);
     const QVariantHash vars = cfg.value(QLatin1String("Variables")).toHash();
     for (QHash<QString, QVariant>::ConstIterator it = vars.constBegin(); it != vars.constEnd(); ++it)
@@ -1033,11 +1033,11 @@ void PackageManagerCorePrivate::registerPathsForUninstallation(
     }
 }
 
-void PackageManagerCorePrivate::writeUninstallerBinary(QFile *const input, qint64 size, bool writeBinaryLayout)
+void PackageManagerCorePrivate::writeMaintenanceToolBinary(QFile *const input, qint64 size, bool writeBinaryLayout)
 {
-    QString uninstallerRenamedName = uninstallerName() + QLatin1String(".new");
-    qDebug() << "Writing uninstaller:" << uninstallerRenamedName;
-    ProgressCoordinator::instance()->emitLabelAndDetailTextChanged(tr("Writing uninstaller."));
+    QString maintenanceToolRenamedName = maintenanceToolName() + QLatin1String(".new");
+    qDebug() << "Writing maintenance tool:" << maintenanceToolRenamedName;
+    ProgressCoordinator::instance()->emitLabelAndDetailTextChanged(tr("Writing maintenance tool."));
 
     QTemporaryFile out;
     QInstaller::openForWrite(&out); // throws an exception in case of error
@@ -1048,9 +1048,9 @@ void PackageManagerCorePrivate::writeUninstallerBinary(QFile *const input, qint6
     QInstaller::appendData(&out, input, size);
     if (writeBinaryLayout) {
 #ifdef Q_OS_OSX
-        QDir resourcePath(QFileInfo(uninstallerRenamedName).dir());
+        QDir resourcePath(QFileInfo(maintenanceToolRenamedName).dir());
         if (!resourcePath.path().endsWith(QLatin1String("Contents/MacOS")))
-            throw Error(tr("Uninstaller is not a bundle"));
+            throw Error(tr("Maintenance tool is not a bundle"));
         resourcePath.cdUp();
         resourcePath.cd(QLatin1String("Resources"));
         // It's a bit odd to have only the magic in the data file, but this simplifies
@@ -1066,7 +1066,7 @@ void PackageManagerCorePrivate::writeUninstallerBinary(QFile *const input, qint6
         dataOut.setPermissions(dataOut.permissions() | QFile::WriteUser | QFile::ReadGroup
             | QFile::ReadOther);
         if (!dataOut.rename(resourcePath.filePath(QLatin1String("installer.dat")))) {
-            throw Error(tr("Could not write uninstaller data to %1: %2").arg(out.fileName(),
+            throw Error(tr("Could not write maintenance tool data to %1: %2").arg(out.fileName(),
                 out.errorString()));
         }
         dataOut.setAutoRemove(false);
@@ -1083,21 +1083,21 @@ void PackageManagerCorePrivate::writeUninstallerBinary(QFile *const input, qint6
         | QFile::ExeOther | QFile::ExeGroup | QFile::ExeUser);
 
     {
-        QFile dummy(uninstallerRenamedName);
+        QFile dummy(maintenanceToolRenamedName);
         if (dummy.exists() && !dummy.remove()) {
             throw Error(tr("Could not remove data file '%1': %2").arg(dummy.fileName(),
                 dummy.errorString()));
         }
     }
 
-    if (!out.rename(uninstallerRenamedName)) {
-        throw Error(tr("Could not write uninstaller to %1: %2").arg(uninstallerRenamedName,
+    if (!out.rename(maintenanceToolRenamedName)) {
+        throw Error(tr("Could not write maintenance tool to %1: %2").arg(maintenanceToolRenamedName,
             out.errorString()));
     }
     out.setAutoRemove(false);
 }
 
-void PackageManagerCorePrivate::writeUninstallerBinaryData(QFileDevice *output, QFile *const input,
+void PackageManagerCorePrivate::writeMaintenanceToolBinaryData(QFileDevice *output, QFile *const input,
     const OperationList &performedOperations, const BinaryLayout &layout)
 {
     const qint64 dataBlockStart = output->pos();
@@ -1163,7 +1163,7 @@ void PackageManagerCorePrivate::writeUninstallerBinaryData(QFileDevice *output,
     QInstaller::appendInt64(output, MagicUninstallerMarker);
 }
 
-void PackageManagerCorePrivate::writeUninstaller(OperationList performedOperations)
+void PackageManagerCorePrivate::writeMaintenanceTool(OperationList performedOperations)
 {
     bool gainedAdminRights = false;
     QTemporaryFile tempAdminFile(targetDir() + QLatin1String("/testjsfdjlkdsjflkdsjfldsjlfds")
@@ -1173,9 +1173,9 @@ void PackageManagerCorePrivate::writeUninstaller(OperationList performedOperatio
         gainedAdminRights = true;
     }
 
-    const QString targetAppDirPath = QFileInfo(uninstallerName()).path();
+    const QString targetAppDirPath = QFileInfo(maintenanceToolName()).path();
     if (!QDir().exists(targetAppDirPath)) {
-        // create the directory containing the uninstaller (like a bundle structor, on Mac...)
+        // create the directory containing the maintenance tool (like a bundle structure on OS X...)
         Operation *op = createOwnedOperation(QLatin1String("Mkdir"));
         op->setArguments(QStringList() << targetAppDirPath);
         performOperationThreaded(op, Backup);
@@ -1210,7 +1210,7 @@ void PackageManagerCorePrivate::writeUninstaller(OperationList performedOperatio
         QTextStream out(&targetPlist);
         const QString before = QLatin1String("<string>") + QFileInfo(QCoreApplication::applicationFilePath())
             .fileName() + QLatin1String("</string>");
-        const QString after = QLatin1String("<string>") + QFileInfo(uninstallerName()).baseName()
+        const QString after = QLatin1String("<string>") + QFileInfo(maintenanceToolName()).baseName()
             + QLatin1String("</string>");
         while (!in.atEnd())
             out << in.readLine().replace(before, after) << endl;
@@ -1296,7 +1296,7 @@ void PackageManagerCorePrivate::writeUninstaller(OperationList performedOperatio
             QFile replacementBinary(installerBaseBinary);
             try {
                 QInstaller::openForRead(&replacementBinary);
-                writeUninstallerBinary(&replacementBinary, replacementBinary.size(), true);
+                writeMaintenanceToolBinary(&replacementBinary, replacementBinary.size(), true);
                 qDebug() << "Wrote the binary with the new replacement.";
 
                 newBinaryWritten = true;
@@ -1309,21 +1309,21 @@ void PackageManagerCorePrivate::writeUninstaller(OperationList performedOperatio
                 // Is there anything more sensible we can do with this error? I think not. It's not serious
                 // enough for throwing / aborting the process.
                 qDebug() << QString::fromLatin1("Could not remove installer base binary '%1' after updating "
-                    "the uninstaller: %2").arg(installerBaseBinary, replacementBinary.errorString());
+                    "the maintenance tool: %2").arg(installerBaseBinary, replacementBinary.errorString());
             } else {
                 qDebug() << QString::fromLatin1("Removed installer base binary '%1' after updating the "
-                    "uninstaller/ maintenance tool.").arg(installerBaseBinary);
+                    "maintenance tool.").arg(installerBaseBinary);
             }
             m_installerBaseBinaryUnreplaced.clear();
         } else if (!installerBaseBinary.isEmpty() && !QFileInfo(installerBaseBinary).exists()) {
-            qWarning() << QString::fromLatin1("The current uninstaller/ maintenance tool could not be "
+            qWarning() << QString::fromLatin1("The current maintenance tool could not be "
                 "updated. '%1' does not exist. Please fix the 'setInstallerBaseBinary(<temp_installer_base_"
                 "binary_path>)' call in your script.").arg(installerBaseBinary);
         }
 
         QFile input;
         BinaryLayout layout;
-        const QString dataFile = targetDir() + QLatin1Char('/') + m_data.settings().uninstallerName()
+        const QString dataFile = targetDir() + QLatin1Char('/') + m_data.settings().maintenanceToolName()
             + QLatin1String(".dat");
         try {
             if (isInstaller()) {
@@ -1336,7 +1336,7 @@ void PackageManagerCorePrivate::writeUninstaller(OperationList performedOperatio
         } catch (const Error &/*error*/) {
 #ifdef Q_OS_OSX
             // On Mac, data is always in a separate file so that the binary can be signed
-            QString binaryName = isInstaller() ? installerBinaryPath() : uninstallerName();
+            QString binaryName = isInstaller() ? installerBinaryPath() : maintenanceToolName();
             QDir dataPath(QFileInfo(binaryName).dir());
             dataPath.cdUp();
             dataPath.cd(QLatin1String("Resources"));
@@ -1349,15 +1349,15 @@ void PackageManagerCorePrivate::writeUninstaller(OperationList performedOperatio
                 newBinaryWritten = true;
                 QFile tmp(binaryName);
                 QInstaller::openForRead(&tmp);
-                writeUninstallerBinary(&tmp, tmp.size(), true);
+                writeMaintenanceToolBinary(&tmp, tmp.size(), true);
             }
 #else
-            input.setFileName(isInstaller() ? installerBinaryPath() : uninstallerName());
+            input.setFileName(isInstaller() ? installerBinaryPath() : maintenanceToolName());
             QInstaller::openForRead(&input);
             layout = BinaryContent::readBinaryLayout(&input, findMagicCookie(&input, MagicCookie));
             if (!newBinaryWritten) {
                 newBinaryWritten = true;
-                writeUninstallerBinary(&input, layout.endOfData - layout.dataBlockSize, true);
+                writeMaintenanceToolBinary(&input, layout.endOfData - layout.dataBlockSize, true);
             }
 #endif
         }
@@ -1369,7 +1369,7 @@ void PackageManagerCorePrivate::writeUninstaller(OperationList performedOperatio
             QTemporaryFile file;
             QInstaller::openForWrite(&file);
 
-            writeUninstallerBinaryData(&file, &input, performedOperations, layout);
+            writeMaintenanceToolBinaryData(&file, &input, performedOperations, layout);
             QInstaller::appendInt64(&file, MagicCookieDat);
             file.setPermissions(file.permissions() | QFile::WriteUser | QFile::ReadGroup
                 | QFile::ReadOther);
@@ -1381,23 +1381,23 @@ void PackageManagerCorePrivate::writeUninstaller(OperationList performedOperatio
             }
 
             if (!file.rename(dataFile + QLatin1String(".new"))) {
-                throw Error(tr("Could not write uninstaller binary data to %1: %2")
+                throw Error(tr("Could not write maintenance tool binary data to %1: %2")
                     .arg(file.fileName(), file.errorString()));
             }
             file.setAutoRemove(false);
         } catch (const Error &/*error*/) {
             if (!newBinaryWritten) {
                 newBinaryWritten = true;
-                QFile tmp(isInstaller() ? installerBinaryPath() : uninstallerName());
+                QFile tmp(isInstaller() ? installerBinaryPath() : maintenanceToolName());
                 QInstaller::openForRead(&tmp);
                 BinaryLayout tmpLayout = BinaryContent::readBinaryLayout(&tmp, findMagicCookie(&tmp, MagicCookie));
-                writeUninstallerBinary(&tmp, tmpLayout.endOfData - tmpLayout.dataBlockSize, false);
+                writeMaintenanceToolBinary(&tmp, tmpLayout.endOfData - tmpLayout.dataBlockSize, false);
             }
 
-            QFile file(uninstallerName() + QLatin1String(".new"));
+            QFile file(maintenanceToolName() + QLatin1String(".new"));
             QInstaller::openForAppend(&file);
             file.seek(file.size());
-            writeUninstallerBinaryData(&file, &input, performedOperations, layout);
+            writeMaintenanceToolBinaryData(&file, &input, performedOperations, layout);
             QInstaller::appendInt64(&file, MagicCookie);
         }
         input.close();
@@ -1406,14 +1406,14 @@ void PackageManagerCorePrivate::writeUninstaller(OperationList performedOperatio
 
         if (newBinaryWritten) {
             const bool restart = replacementExists && isUpdater() && (!statusCanceledOrFailed()) && m_needsHardRestart;
-            deferredRename(uninstallerName() + QLatin1String(".new"), uninstallerName(), restart);
+            deferredRename(maintenanceToolName() + QLatin1String(".new"), maintenanceToolName(), restart);
             qDebug() << "Maintenance tool restart:" << (restart ? "true." : "false.");
         }
     } catch (const Error &err) {
         setStatus(PackageManagerCore::Failure);
         if (gainedAdminRights)
             m_core->dropAdminRights();
-        m_needToWriteUninstaller = false;
+        m_needToWriteMaintenanceTool = false;
         throw err;
     }
 
@@ -1422,7 +1422,7 @@ void PackageManagerCorePrivate::writeUninstaller(OperationList performedOperatio
 
     commitSessionOperations();
 
-    m_needToWriteUninstaller = false;
+    m_needToWriteMaintenanceTool = false;
 }
 
 QString PackageManagerCorePrivate::registerPath() const
@@ -1449,7 +1449,7 @@ bool PackageManagerCorePrivate::runInstaller()
         setStatus(PackageManagerCore::Running);
         emit installationStarted(); // resets also the ProgressCoordninator
 
-        // to have some progress for writeUninstaller
+        // to have some progress for writeMaintenanceTool
         ProgressCoordinator::instance()->addReservePercentagePoints(1);
 
         const QString target = QDir::cleanPath(targetDir().replace(QLatin1Char('\\'), QLatin1Char('/')));
@@ -1581,10 +1581,10 @@ bool PackageManagerCorePrivate::runInstaller()
             }
         }
 
-        emit m_core->titleMessageChanged(tr("Creating Uninstaller"));
+        emit m_core->titleMessageChanged(tr("Creating Maintenance Tool"));
 
-        writeUninstaller(m_performedOperationsOld + m_performedOperationsCurrentSession);
-        registerUninstaller();
+        writeMaintenanceTool(m_performedOperationsOld + m_performedOperationsCurrentSession);
+        registerMaintenanceTool();
 
         // fake a possible wrong value to show a full progress bar
         const int progress = ProgressCoordinator::instance()->progressInPercentage();
@@ -1754,10 +1754,10 @@ bool PackageManagerCorePrivate::runPackageUpdater()
         foreach (Component *component, componentsToInstall)
             installComponent(component, progressOperationSize, adminRightsGained);
 
-        emit m_core->titleMessageChanged(tr("Creating Uninstaller"));
+        emit m_core->titleMessageChanged(tr("Creating Maintenance Tool"));
 
         commitSessionOperations(); //end session, move ops to "old"
-        m_needToWriteUninstaller = true;
+        m_needToWriteMaintenanceTool = true;
 
         // fake a possible wrong value to show a full progress bar
         const int progress = ProgressCoordinator::instance()->progressInPercentage();
@@ -1820,7 +1820,7 @@ bool PackageManagerCorePrivate::runUninstaller()
         // No operation delete here, as all old undo operations are deleted in the destructor.
 
         // this will also delete the TargetDir on Windows
-        deleteUninstaller();
+        deleteMaintenanceTool();
 
         if (QVariant(m_core->value(scRemoveTargetDir)).toBool()) {
             // on !Windows, we need to remove TargetDir manually
@@ -1838,8 +1838,8 @@ bool PackageManagerCorePrivate::runUninstaller()
             }
         }
 
-        unregisterUninstaller();
-        m_needToWriteUninstaller = false;
+        unregisterMaintenanceTool();
+        m_needToWriteMaintenanceTool = false;
 
         setStatus(PackageManagerCore::Success);
         ProgressCoordinator::instance()->emitLabelAndDetailTextChanged(
@@ -1956,11 +1956,11 @@ void PackageManagerCorePrivate::installComponent(Component *component, double pr
 
 // -- private
 
-void PackageManagerCorePrivate::deleteUninstaller()
+void PackageManagerCorePrivate::deleteMaintenanceTool()
 {
 #ifdef Q_OS_WIN
-    // Since Windows does not support that the uninstaller deletes itself we  have to go with a rather dirty
-    // hack. What we do is to create a batchfile that will try to remove the uninstaller once per second. Then
+    // Since Windows does not support that the maintenance tool deletes itself we have to go with a rather dirty
+    // hack. What we do is to create a batchfile that will try to remove the maintenance tool once per second. Then
     // we start that batchfile detached, finished our job and close ourselves. Once that's done the batchfile
     // will succeed in deleting our uninstall.exe and, if the installation directory was created but us and if
     // it's empty after the uninstall, deletes the installation-directory.
@@ -2002,8 +2002,8 @@ void PackageManagerCorePrivate::deleteUninstaller()
         throw Error(tr("Cannot start uninstall"));
 #else
     // every other platform has no problem if we just delete ourselves now
-    QFile uninstaller(QFileInfo(installerBinaryPath()).absoluteFilePath());
-    uninstaller.remove();
+    QFile maintenanceTool(QFileInfo(installerBinaryPath()).absoluteFilePath());
+    maintenanceTool.remove();
 # ifdef Q_OS_OSX
     if (QInstaller::isInBundle(installerBinaryPath())) {
         const QLatin1String cdUp("/../../..");
@@ -2020,21 +2020,21 @@ void PackageManagerCorePrivate::deleteUninstaller()
     }
 }
 
-void PackageManagerCorePrivate::registerUninstaller()
+void PackageManagerCorePrivate::registerMaintenanceTool()
 {
 #ifdef Q_OS_WIN
     QSettingsWrapper settings(registerPath(), QSettingsWrapper::NativeFormat);
     settings.setValue(scDisplayName, m_data.value(QLatin1String("ProductName")));
     settings.setValue(QLatin1String("DisplayVersion"), m_data.value(QLatin1String("ProductVersion")));
-    const QString uninstaller = QDir::toNativeSeparators(uninstallerName());
-    settings.setValue(QLatin1String("DisplayIcon"), uninstaller);
+    const QString maintenanceTool = QDir::toNativeSeparators(maintenanceToolName());
+    settings.setValue(QLatin1String("DisplayIcon"), maintenanceTool);
     settings.setValue(scPublisher, m_data.value(scPublisher));
     settings.setValue(QLatin1String("UrlInfoAbout"), m_data.value(QLatin1String("Url")));
     settings.setValue(QLatin1String("Comments"), m_data.value(scTitle));
     settings.setValue(QLatin1String("InstallDate"), QDateTime::currentDateTime().toString());
     settings.setValue(QLatin1String("InstallLocation"), QDir::toNativeSeparators(targetDir()));
-    settings.setValue(QLatin1String("UninstallString"), uninstaller);
-    settings.setValue(QLatin1String("ModifyPath"), QString(uninstaller
+    settings.setValue(QLatin1String("UninstallString"), maintenanceTool);
+    settings.setValue(QLatin1String("ModifyPath"), QString(maintenanceTool
         + QLatin1String(" --manage-packages")));
     settings.setValue(QLatin1String("EstimatedSize"), QFileInfo(installerBinaryPath()).size());
     settings.setValue(QLatin1String("NoModify"), 0);
@@ -2042,7 +2042,7 @@ void PackageManagerCorePrivate::registerUninstaller()
 #endif
 }
 
-void PackageManagerCorePrivate::unregisterUninstaller()
+void PackageManagerCorePrivate::unregisterMaintenanceTool()
 {
 #ifdef Q_OS_WIN
     QSettingsWrapper settings(registerPath(), QSettingsWrapper::NativeFormat);
diff --git a/src/libs/installer/packagemanagercore_p.h b/src/libs/installer/packagemanagercore_p.h
index 9eb807b7c..3b2655276 100644
--- a/src/libs/installer/packagemanagercore_p.h
+++ b/src/libs/installer/packagemanagercore_p.h
@@ -123,13 +123,13 @@ public:
     QString targetDir() const;
     QString registerPath() const;
 
-    QString uninstallerName() const;
+    QString maintenanceToolName() const;
     QString installerBinaryPath() const;
 
     void writeMaintenanceConfigFiles();
     void readMaintenanceConfigFiles(const QString &targetDir);
 
-    void writeUninstaller(OperationList performedOperations);
+    void writeMaintenanceTool(OperationList performedOperations);
 
     QString componentsXmlPath() const;
     QString configurationFileName() const;
@@ -212,7 +212,7 @@ public:
     bool m_testChecksum;
     bool m_launchedAsRoot;
     bool m_completeUninstall;
-    bool m_needToWriteUninstaller;
+    bool m_needToWriteMaintenanceTool;
     PackageManagerCoreData m_data;
     QHash<QString, bool> m_sharedFlags;
     QString m_installerBaseBinaryUnreplaced;
@@ -241,12 +241,12 @@ private slots:
     void handleMethodInvocationRequest(const QString &invokableMethodName);
 
 private:
-    void deleteUninstaller();
-    void registerUninstaller();
-    void unregisterUninstaller();
+    void deleteMaintenanceTool();
+    void registerMaintenanceTool();
+    void unregisterMaintenanceTool();
 
-    void writeUninstallerBinary(QFile *const input, qint64 size, bool writeBinaryLayout);
-    void writeUninstallerBinaryData(QFileDevice *output, QFile *const input,
+    void writeMaintenanceToolBinary(QFile *const input, qint64 size, bool writeBinaryLayout);
+    void writeMaintenanceToolBinaryData(QFileDevice *output, QFile *const input,
         const OperationList &performed, const BinaryLayout &layout);
 
     void runUndoOperations(const OperationList &undoOperations, double undoOperationProgressSize,
diff --git a/src/libs/installer/packagemanagergui.cpp b/src/libs/installer/packagemanagergui.cpp
index 67c19de67..a34cc26ef 100644
--- a/src/libs/installer/packagemanagergui.cpp
+++ b/src/libs/installer/packagemanagergui.cpp
@@ -1713,7 +1713,7 @@ bool TargetDirectoryPage::validatePage()
 
     const QFileInfo fi(targetDir);
     if (fi.isDir()) {
-        QString fileName = packageManagerCore()->settings().uninstallerName();
+        QString fileName = packageManagerCore()->settings().maintenanceToolName();
 #if defined(Q_OS_OSX)
         if (QInstaller::isInBundle(QCoreApplication::applicationDirPath()))
             fileName += QLatin1String(".app/Contents/MacOS/") + fileName;
@@ -1794,7 +1794,7 @@ QString TargetDirectoryPage::targetDirWarning() const
     QString dir = QDir::toNativeSeparators(targetDir());
 #ifdef Q_OS_WIN
     // folder length (set by user) + maintenance tool name length (no extension) + extra padding
-    if ((dir.length() + packageManagerCore()->settings().uninstallerName().length() + 20) >= MAX_PATH) {
+    if ((dir.length() + packageManagerCore()->settings().maintenanceToolName().length() + 20) >= MAX_PATH) {
             return tr("The path you have entered is too long, please make sure to "
                 "specify a valid path.");
     }
diff --git a/src/libs/installer/settings.cpp b/src/libs/installer/settings.cpp
index cf1d163cd..80ffc70e7 100644
--- a/src/libs/installer/settings.cpp
+++ b/src/libs/installer/settings.cpp
@@ -61,10 +61,10 @@ static const QLatin1String scBanner("Banner");
 static const QLatin1String scProductUrl("ProductUrl");
 static const QLatin1String scBackground("Background");
 static const QLatin1String scAdminTargetDir("AdminTargetDir");
-static const QLatin1String scUninstallerName("UninstallerName");
+static const QLatin1String scMaintenanceToolName("MaintenanceToolName");
 static const QLatin1String scUserRepositories("UserRepositories");
 static const QLatin1String scTmpRepositories("TemporaryRepositories");
-static const QLatin1String scUninstallerIniFile("UninstallerIniFile");
+static const QLatin1String scMaintenanceToolIniFile("MaintenanceToolIniFile");
 static const QLatin1String scRemoteRepositories("RemoteRepositories");
 static const QLatin1String scDependsOnLocalInstallerBinary("DependsOnLocalInstallerBinary");
 static const QLatin1String scTranslations("Translations");
@@ -232,7 +232,7 @@ Settings Settings::fromFileAndPrefix(const QString &path, const QString &prefix,
                 << scTargetDir << scAdminTargetDir
                 << scIcon << scInstallerApplicationIcon << scInstallerWindowIcon
                 << scLogo << scWatermark << scBanner << scBackground
-                << scStartMenuDir << scUninstallerName << scUninstallerIniFile << scRemoveTargetDir
+                << scStartMenuDir << scMaintenanceToolName << scMaintenanceToolIniFile << scRemoveTargetDir
                 << scRunProgram << scRunProgramArguments << scRunProgramDescription
                 << scDependsOnLocalInstallerBinary
                 << scAllowSpaceInPath << scAllowNonAsciiCharacters << scWizardStyle << scTitleColor
@@ -286,12 +286,12 @@ Settings Settings::fromFileAndPrefix(const QString &path, const QString &prefix,
                            QString(s.d->m_data.value(scIcon).toString() + s.systemIconSuffix()));
     if (!s.d->m_data.contains(scRemoveTargetDir))
         s.d->m_data.insert(scRemoveTargetDir, scTrue);
-    if (!s.d->m_data.contains(scUninstallerName))
-        s.d->m_data.insert(scUninstallerName, QLatin1String("uninstall"));
+    if (!s.d->m_data.contains(scMaintenanceToolName))
+        s.d->m_data.insert(scMaintenanceToolName, QLatin1String("maintenancetool"));
     if (!s.d->m_data.contains(scTargetConfigurationFile))
         s.d->m_data.insert(scTargetConfigurationFile, QLatin1String("components.xml"));
-    if (!s.d->m_data.contains(scUninstallerIniFile))
-        s.d->m_data.insert(scUninstallerIniFile, QString(s.uninstallerName() + QLatin1String(".ini")));
+    if (!s.d->m_data.contains(scMaintenanceToolIniFile))
+        s.d->m_data.insert(scMaintenanceToolIniFile, QString(s.maintenanceToolName() + QLatin1String(".ini")));
     if (!s.d->m_data.contains(scDependsOnLocalInstallerBinary))
         s.d->m_data.insert(scDependsOnLocalInstallerBinary, false);
     if (!s.d->m_data.contains(scRepositorySettingsPageVisible))
@@ -386,14 +386,14 @@ QString Settings::removeTargetDir() const
     return d->m_data.value(scRemoveTargetDir).toString();
 }
 
-QString Settings::uninstallerName() const
+QString Settings::maintenanceToolName() const
 {
-    return d->m_data.value(scUninstallerName).toString();
+    return d->m_data.value(scMaintenanceToolName).toString();
 }
 
-QString Settings::uninstallerIniFile() const
+QString Settings::maintenanceToolIniFile() const
 {
-    return d->m_data.value(scUninstallerIniFile).toString();
+    return d->m_data.value(scMaintenanceToolIniFile).toString();
 }
 
 QString Settings::runProgram() const
diff --git a/src/libs/installer/settings.h b/src/libs/installer/settings.h
index 5788ddb9b..9f2301175 100644
--- a/src/libs/installer/settings.h
+++ b/src/libs/installer/settings.h
@@ -110,8 +110,8 @@ public:
     QString adminTargetDir() const;
 
     QString removeTargetDir() const;
-    QString uninstallerName() const;
-    QString uninstallerIniFile() const;
+    QString maintenanceToolName() const;
+    QString maintenanceToolIniFile() const;
 
     QString configurationFileName() const;
 
diff --git a/src/sdk/installerbase.cpp b/src/sdk/installerbase.cpp
index 62b65da22..117435ab9 100644
--- a/src/sdk/installerbase.cpp
+++ b/src/sdk/installerbase.cpp
@@ -278,8 +278,8 @@ int main(int argc, char *argv[])
                 qDebug() << QString::fromLatin1("    %1").arg(it.next());
         }
 
-        // register custom operations before reading the binary content cause they may used in
-        // the uninstaller for the recorded list of during the installation performed operations
+        // register custom operations before reading the binary content because they may be used in
+        // the maintenance tool for the recorded list or during the installation performed operations
         QInstaller::init();
 
         QString binaryFile = QCoreApplication::applicationFilePath();
diff --git a/src/sdk/tabcontroller.cpp b/src/sdk/tabcontroller.cpp
index ffa831580..a8b29d73f 100644
--- a/src/sdk/tabcontroller.cpp
+++ b/src/sdk/tabcontroller.cpp
@@ -95,7 +95,7 @@ TabController::TabController(QObject *parent)
 
 TabController::~TabController()
 {
-    d->m_core->writeUninstaller();
+    d->m_core->writeMaintenanceTool();
     delete d;
 }
 
diff --git a/tests/auto/installer/settings/data/full_config.xml b/tests/auto/installer/settings/data/full_config.xml
index 8af96edda..41e598760 100644
--- a/tests/auto/installer/settings/data/full_config.xml
+++ b/tests/auto/installer/settings/data/full_config.xml
@@ -25,8 +25,8 @@ File should contain all elements we allow in a config.xml
 
     <StartMenuDir>Super App</StartMenuDir>
 
-    <UninstallerName>uninstaller</UninstallerName>
-    <UninstallerIniFile>uninstaller.ini</UninstallerIniFile>
+    <MaintenanceToolName>maintenancetool</MaintenanceToolName>
+    <MaintenanceToolIniFile>maintenancetool.ini</MaintenanceToolIniFile>
     <RemoveTargetDir>true</RemoveTargetDir>
 
     <RunProgram>myapp</RunProgram>
diff --git a/tests/auto/installer/settings/tst_settings.cpp b/tests/auto/installer/settings/tst_settings.cpp
index 2bd318f52..7f75c74b2 100644
--- a/tests/auto/installer/settings/tst_settings.cpp
+++ b/tests/auto/installer/settings/tst_settings.cpp
@@ -58,8 +58,8 @@ void tst_Settings::loadTutorialConfig()
     QCOMPARE(settings.runProgramDescription(), QString());
     QCOMPARE(settings.adminTargetDir(), QString());
     QCOMPARE(settings.removeTargetDir(), QLatin1String("true"));
-    QCOMPARE(settings.uninstallerName(), QLatin1String("uninstall"));
-    QCOMPARE(settings.uninstallerIniFile(), QLatin1String("uninstall.ini"));
+    QCOMPARE(settings.maintenanceToolName(), QLatin1String("maintenancetool"));
+    QCOMPARE(settings.maintenanceToolIniFile(), QLatin1String("maintenancetool.ini"));
     QCOMPARE(settings.configurationFileName(), QLatin1String("components.xml"));
     QCOMPARE(settings.dependsOnLocalInstallerBinary(), false);
     QCOMPARE(settings.repositorySettingsPageVisible(), true);