BareMetal: Minimize dependency from GDB engine

The problem is that this plugin was originally developed
only for working with the GDB debugging engine. This hard
dependency penetrates to all plugin logic, that excludes an
easy addition of other types of a debugger engines.

This patch tries to minimize the GDB dependency and improves
code a bit in the following way:

 * A code that belongs to the GDB engine moved to the separate
debugservers/gdb directory.
 * A classes having a common functionality are renamed with
'Debug' suffixes instead of 'Gdb' suffixes.
 * Introduced a new interface IDebugServerProvider{Factory|ConfigWidget}
whih are used as a base for all derived debug servers
providers (e.g. for the OpenOCD, STLink and etc).
 * The IDebugServerProvider interface has a new virtual
engineType() method to show a supported debugger engine by
a specific debugger server provider. This method is used in
BareMetalDebugSupport class to detect a provider engine
for an additional initialization (which depends on an used
debugger engine).
 * The IDebugServerProvider interface has a new virtual hasProcess()
method. E.g. this is required for a future debug server providers
which has not a remote processes. In this case the
BareMetalDevice::canCreateProcess() will report about that in
a right way.

Thus, this approach allowed us to preserve a previous behavior
of an already implemented GDB providers. Also it makes possible
to add a new providers in a future with a minimized costs.

Change-Id: I1be84b9178d4aa78c3ef5108a9e6b381e245f36f
Reviewed-by: hjk <hjk@qt.io>

src/plugins/baremetal/debugserverprovidermanager.cpp

@@ -0,0 +1,207 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 Denis Shienkov <denis.shienkov@gmail.com>
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of Qt Creator.
+**
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+****************************************************************************/
+
+#include "debugserverprovidermanager.h"
+#include "idebugserverprovider.h"
+
+// GDB debug servers.
+#include "debugservers/gdb/defaultgdbserverprovider.h"
+#include "debugservers/gdb/openocdgdbserverprovider.h"
+#include "debugservers/gdb/stlinkutilgdbserverprovider.h"
+
+#include <coreplugin/icore.h>
+
+#include <extensionsystem/pluginmanager.h>
+
+#include <utils/algorithm.h>
+#include <utils/persistentsettings.h>
+#include <utils/qtcassert.h>
+
+#include <QDir>
+
+namespace BareMetal {
+namespace Internal {
+
+const char dataKeyC[] = "DebugServerProvider.";
+const char countKeyC[] = "DebugServerProvider.Count";
+const char fileVersionKeyC[] = "Version";
+const char fileNameKeyC[] = "/debugserverproviders.xml";
+
+static DebugServerProviderManager *m_instance = nullptr;
+
+// DebugServerProviderManager
+
+DebugServerProviderManager::DebugServerProviderManager()
+    : m_configFile(Utils::FilePath::fromString(Core::ICore::userResourcePath() + fileNameKeyC))
+    , m_factories({new DefaultGdbServerProviderFactory,
+                   new OpenOcdGdbServerProviderFactory,
+                   new StLinkUtilGdbServerProviderFactory})
+{
+    m_instance = this;
+    m_writer = new Utils::PersistentSettingsWriter(
+                m_configFile, QLatin1String("QtCreatorDebugServerProviders"));
+
+    connect(Core::ICore::instance(), &Core::ICore::saveSettingsRequested,
+            this, &DebugServerProviderManager::saveProviders);
+
+    connect(this, &DebugServerProviderManager::providerAdded,
+            this, &DebugServerProviderManager::providersChanged);
+    connect(this, &DebugServerProviderManager::providerRemoved,
+            this, &DebugServerProviderManager::providersChanged);
+    connect(this, &DebugServerProviderManager::providerUpdated,
+            this, &DebugServerProviderManager::providersChanged);
+}
+
+DebugServerProviderManager::~DebugServerProviderManager()
+{
+    qDeleteAll(m_providers);
+    m_providers.clear();
+    qDeleteAll(m_factories);
+    delete m_writer;
+    m_instance = nullptr;
+}
+
+DebugServerProviderManager *DebugServerProviderManager::instance()
+{
+    return m_instance;
+}
+
+void DebugServerProviderManager::restoreProviders()
+{
+    Utils::PersistentSettingsReader reader;
+    if (!reader.load(m_configFile))
+        return;
+
+    const QVariantMap data = reader.restoreValues();
+    const int version = data.value(QLatin1String(fileVersionKeyC), 0).toInt();
+    if (version < 1)
+        return;
+
+    const int count = data.value(QLatin1String(countKeyC), 0).toInt();
+    for (int i = 0; i < count; ++i) {
+        const QString key = QString::fromLatin1(dataKeyC) + QString::number(i);
+        if (!data.contains(key))
+            break;
+
+        const QVariantMap map = data.value(key).toMap();
+        bool restored = false;
+        for (IDebugServerProviderFactory *f : qAsConst(m_factories)) {
+            if (f->canRestore(map)) {
+                if (IDebugServerProvider *p = f->restore(map)) {
+                    registerProvider(p);
+                    restored = true;
+                    break;
+                }
+            }
+        }
+        if (!restored)
+            qWarning("Warning: Unable to restore provider '%s' stored in %s.",
+                     qPrintable(IDebugServerProviderFactory::idFromMap(map)),
+                     qPrintable(m_configFile.toUserOutput()));
+    }
+
+    emit providersLoaded();
+}
+
+void DebugServerProviderManager::saveProviders()
+{
+    QVariantMap data;
+    data.insert(QLatin1String(fileVersionKeyC), 1);
+
+    int count = 0;
+    for (const IDebugServerProvider *p : qAsConst(m_providers)) {
+        if (p->isValid()) {
+            const QVariantMap tmp = p->toMap();
+            if (tmp.isEmpty())
+                continue;
+            const QString key = QString::fromLatin1(dataKeyC) + QString::number(count);
+            data.insert(key, tmp);
+            ++count;
+        }
+    }
+    data.insert(QLatin1String(countKeyC), count);
+    m_writer->save(data, Core::ICore::mainWindow());
+}
+
+QList<IDebugServerProvider *> DebugServerProviderManager::providers()
+{
+    return m_instance->m_providers;
+}
+
+QList<IDebugServerProviderFactory *> DebugServerProviderManager::factories()
+{
+    return m_instance->m_factories;
+}
+
+IDebugServerProvider *DebugServerProviderManager::findProvider(const QString &id)
+{
+    if (id.isEmpty() || !m_instance)
+        return nullptr;
+
+    return Utils::findOrDefault(m_instance->m_providers, Utils::equal(&IDebugServerProvider::id, id));
+}
+
+IDebugServerProvider *DebugServerProviderManager::findByDisplayName(const QString &displayName)
+{
+    if (displayName.isEmpty())
+        return nullptr;
+
+    return Utils::findOrDefault(m_instance->m_providers,
+                                Utils::equal(&IDebugServerProvider::displayName, displayName));
+}
+
+void DebugServerProviderManager::notifyAboutUpdate(IDebugServerProvider *provider)
+{
+    if (!provider || !m_instance->m_providers.contains(provider))
+        return;
+    emit m_instance->providerUpdated(provider);
+}
+
+bool DebugServerProviderManager::registerProvider(IDebugServerProvider *provider)
+{
+    if (!provider || m_instance->m_providers.contains(provider))
+        return true;
+    for (const IDebugServerProvider *current : qAsConst(m_instance->m_providers)) {
+        if (*provider == *current)
+            return false;
+        QTC_ASSERT(current->id() != provider->id(), return false);
+    }
+
+    m_instance->m_providers.append(provider);
+    emit m_instance->providerAdded(provider);
+    return true;
+}
+
+void DebugServerProviderManager::deregisterProvider(IDebugServerProvider *provider)
+{
+    if (!provider || !m_instance->m_providers.contains(provider))
+        return;
+    m_instance->m_providers.removeOne(provider);
+    emit m_instance->providerRemoved(provider);
+    delete provider;
+}
+
+} // namespace Internal
+} // namespace BareMetal