ProjectExplorer: Refactor KitManager::registerKit()

The interface of this function was rather unfortunate. In particluar,
the fact that it took ownership of the std::unique_ptr that was passed
in required some weird boiler plate code at all the calling sites.
Instead, it now becomes a proper factory function.

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

src/plugins/android/androidconfigurations.cpp

@@ -1082,32 +1082,35 @@ void AndroidConfigurations::updateAutomaticKitList()
             QtSupport::QtKitAspect::setQtVersion(k, qt);
             DeviceKitAspect::setDevice(k, device);
         };
+        const auto initStage2 = [tc](Kit *k, const QtSupport::BaseQtVersion *qt) {
+            Debugger::DebuggerKitAspect::setDebugger(k, findOrRegisterDebugger(tc));
+            AndroidGdbServerKitAspect::setGdbSever(k, currentConfig().gdbServer(tc->targetAbi()));
+            k->makeSticky();
+            k->setUnexpandedDisplayName(tr("Android for %1 (Clang %2)")
+                                              .arg(static_cast<const AndroidQtVersion *>(qt)->targetArch())
+                                              .arg(qt->displayName()));
+        };
 
         for (const QtSupport::BaseQtVersion *qt : qtVersionsForArch.value(tc->targetAbi())) {
-            auto newKit = std::make_unique<Kit>();
+            Kit *existingKit = nullptr;
-            Kit *toSetup = newKit.get();
+            const auto initializeKit = [&](Kit *k) {
-            initBasicKitData(toSetup, qt);
+                initBasicKitData(k, qt);
-            Kit *existingKit = Utils::findOrDefault(existingKits, [toSetup](const Kit *k) {
+                existingKit = Utils::findOrDefault(existingKits, [k](const Kit *existing) {
-                return matchKits(toSetup, k);
+                    return matchKits(k, existing);
                 });
-            if (existingKit) {
+                if (existingKit)
+                    return false;
+                initStage2(k, qt);
+                return true;
+            };
+            Kit * const newKit = KitManager::registerKit(initializeKit);
+            QTC_ASSERT(!newKit != !existingKit, continue);
+            if (!newKit) {
                 // Existing kit found.
                 // Update the existing kit with new data.
                 initBasicKitData(existingKit, qt);
-                newKit.reset();
+                initStage2(existingKit, qt);
-                toSetup = existingKit;
             }
-
-            Debugger::DebuggerKitAspect::setDebugger(toSetup, findOrRegisterDebugger(tc));
-
-            AndroidGdbServerKitAspect::setGdbSever(toSetup, currentConfig().gdbServer(tc->targetAbi()));
-            toSetup->makeSticky();
-
-            toSetup->setUnexpandedDisplayName(tr("Android for %1 (Clang %2)")
-                                              .arg(static_cast<const AndroidQtVersion *>(qt)->targetArch())
-                                              .arg(qt->displayName()));
-            if (!existingKit)
-                KitManager::registerKit(std::move(newKit));
         }
     }
 }

src/plugins/ios/iosconfigurations.cpp

@@ -300,17 +300,16 @@ void IosConfigurations::updateAutomaticKitList()
                     kit->unblockNotification();
                 } else {
                     qCDebug(kitSetupLog) << "    - Setting up new kit";
-                    auto newKit = std::make_unique<Kit>();
+                    const auto init = [&](Kit *k) {
-                    kit = newKit.get();
+                        k->setAutoDetected(true);
-                    kit->blockNotification();
-                    kit->setAutoDetected(true);
                         const QString baseDisplayName = isSimulatorDeviceId(pDeviceType)
                                 ? tr("%1 Simulator").arg(qtVersion->unexpandedDisplayName())
                                 : qtVersion->unexpandedDisplayName();
-                    kit->setUnexpandedDisplayName(baseDisplayName);
+                        k->setUnexpandedDisplayName(baseDisplayName);
-                    setupKit(kit, pDeviceType, platformToolchains, debuggerId, sdk.path, qtVersion);
+                        setupKit(k, pDeviceType, platformToolchains, debuggerId, sdk.path, qtVersion);
-                    kit->unblockNotification();
+                        return true;
-                    KitManager::registerKit(std::move(newKit));
+                    };
+                    kit = KitManager::registerKit(init);
                 }
                 resultingKits.insert(kit);
             }

src/plugins/projectexplorer/kitmanager.cpp

@@ -398,18 +398,16 @@ void KitManager::notifyAboutUpdate(Kit *k)
         emit m_instance->unmanagedKitUpdated(k);
 }
 
-bool KitManager::registerKit(std::unique_ptr<Kit> &&k)
+Kit *KitManager::registerKit(const std::function<bool (Kit *)> &init, Core::Id id)
 {
-    QTC_ASSERT(isLoaded(), return false);
+    QTC_ASSERT(isLoaded(), return nullptr);
 
-    if (!k)
+    auto k = std::make_unique<Kit>(id);
-        return true;
+    QTC_ASSERT(k->id().isValid(), return nullptr);
-
-    QTC_ASSERT(k->id().isValid(), return false);
 
     Kit *kptr = k.get();
-    if (Utils::contains(d->m_kitList, kptr))
+    if (init && !init(kptr))
-        return false;
+        return nullptr;
 
     // make sure we have all the information in our kits:
     completeKit(kptr);
@@ -420,7 +418,7 @@ bool KitManager::registerKit(std::unique_ptr<Kit> &&k)
         setDefaultKit(kptr);
 
     emit m_instance->kitAdded(kptr);
-    return true;
+    return kptr;
 }
 
 void KitManager::deregisterKit(Kit *k)

src/plugins/projectexplorer/kitmanager.h

@@ -173,7 +173,7 @@ public:
     static const QSet<Core::Id> irrelevantAspects();
     static void setIrrelevantAspects(const QSet<Core::Id> &aspects);
 
-    static bool registerKit(std::unique_ptr<Kit> &&k);
+    static Kit *registerKit(const std::function<bool(Kit *)> &init, Core::Id id = {});
     static void deregisterKit(Kit *k);
     static void setDefaultKit(Kit *k);
 

src/plugins/projectexplorer/kitmanagerconfigwidget.cpp

@@ -159,21 +159,13 @@ QIcon KitManagerConfigWidget::icon() const
 
 void KitManagerConfigWidget::apply()
 {
-    bool mustSetDefault = m_isDefaultKit;
+    const auto copyIntoKit = [this](Kit *k) { k->copyFrom(m_modifiedKit.get()); };
-    bool mustRegister = false;
+    if (m_kit)
-    auto toRegister = std::make_unique<Kit>();
+        copyIntoKit(m_kit);
-    if (!m_kit) {
+    else
-        mustRegister = true;
+        m_kit = KitManager::registerKit([&](Kit *k) { copyIntoKit(k); return true; });
-        m_kit = toRegister.get();
+    if (m_isDefaultKit)
-    }
-    m_kit->copyFrom(m_modifiedKit.get()); //m_isDefaultKit is reset in discard() here.
-    if (mustRegister)
-        KitManager::registerKit(std::move(toRegister));
-
-    if (mustSetDefault)
         KitManager::setDefaultKit(m_kit);
-
-    m_isDefaultKit = mustSetDefault;
     emit dirty();
 }
 

src/plugins/projectexplorer/projectimporter.cpp

@@ -286,20 +286,19 @@ bool ProjectImporter::isTemporaryKit(Kit *k) const
 
 Kit *ProjectImporter::createTemporaryKit(const KitSetupFunction &setup) const
 {
-    auto k = std::make_unique<Kit>();
-    Kit *kptr = k.get();
     UpdateGuard guard(*this);
-    {
+    const auto init = [&](Kit *k) {
-        KitGuard kitGuard(kptr);
+        KitGuard kitGuard(k);
-        k->setUnexpandedDisplayName(QCoreApplication::translate("ProjectExplorer::ProjectImporter", "Imported Kit"));;
+        k->setUnexpandedDisplayName(QCoreApplication::translate("ProjectExplorer::ProjectImporter",
+                                                                "Imported Kit"));
         k->setup();
-        setup(kptr);
+        setup(k);
         k->fix();
-        markKitAsTemporary(kptr);
+        markKitAsTemporary(k);
-        addProject(kptr);
+        addProject(k);
-    } // ~KitGuard, sending kitUpdated
+        return true;
-    KitManager::registerKit(std::move(k)); // potentially adds kits to other targetsetuppages
+    }; // ~KitGuard, sending kitUpdated
-    return kptr;
+    return KitManager::registerKit(init); // potentially adds kits to other targetsetuppages
 }
 
 bool ProjectImporter::findTemporaryHandler(Core::Id id) const

src/plugins/qmlprofiler/tests/qmlprofilerattachdialog_test.cpp

@@ -46,16 +46,15 @@ void QmlProfilerAttachDialogTest::testAccessors()
     dialog.setPort(4444);
     QCOMPARE(dialog.port(), 4444);
 
-    auto newKit = std::make_unique<ProjectExplorer::Kit>("dings");
-    ProjectExplorer::Kit *newKitPtr = newKit.get();
     ProjectExplorer::KitManager *kitManager = ProjectExplorer::KitManager::instance();
     QVERIFY(kitManager);
-    QVERIFY(kitManager->registerKit(std::move(newKit)));
+    ProjectExplorer::Kit * const newKit = kitManager->registerKit({}, "dings");
+    QVERIFY(newKit);
 
     dialog.setKitId("dings");
-    QCOMPARE(dialog.kit(), newKitPtr);
+    QCOMPARE(dialog.kit(), newKit);
 
-    kitManager->deregisterKit(newKitPtr);
+    kitManager->deregisterKit(newKit);
 }
 
 } // namespace Internal

src/plugins/qmlprofiler/tests/qmlprofilertool_test.cpp

@@ -44,14 +44,13 @@ namespace Internal {
 
 void QmlProfilerToolTest::testAttachToWaitingApplication()
 {
-    auto newKit = std::make_unique<ProjectExplorer::Kit>("fookit");
-    ProjectExplorer::Kit * newKitPtr = newKit.get();
     ProjectExplorer::KitManager *kitManager = ProjectExplorer::KitManager::instance();
     QVERIFY(kitManager);
-    QVERIFY(kitManager->registerKit(std::move(newKit)));
+    ProjectExplorer::Kit * const newKit = kitManager->registerKit({}, "fookit");
+    QVERIFY(newKit);
     QSettings *settings = Core::ICore::settings();
     QVERIFY(settings);
-    settings->setValue(QLatin1String("AnalyzerQmlAttachDialog/kitId"), newKitPtr->id().toSetting());
+    settings->setValue(QLatin1String("AnalyzerQmlAttachDialog/kitId"), newKit->id().toSetting());
 
     QmlProfilerTool profilerTool;
 

src/plugins/qnx/qnxconfiguration.cpp

@@ -301,39 +301,38 @@ ProjectExplorer::Kit *QnxConfiguration::createKit(
     if (!qnxQt)
         return nullptr;
 
-    auto kit = std::make_unique<Kit>();
+    const auto init = [&](Kit *k) {
-    Kit *kptr = kit.get();
+        QtKitAspect::setQtVersion(k, qnxQt);
-
+        ToolChainKitAspect::setToolChain(k, toolChain);
-    QtKitAspect::setQtVersion(kptr, qnxQt);
+        ToolChainKitAspect::clearToolChain(k, ProjectExplorer::Constants::C_LANGUAGE_ID);
-    ToolChainKitAspect::setToolChain(kptr, toolChain);
-    ToolChainKitAspect::clearToolChain(kptr, ProjectExplorer::Constants::C_LANGUAGE_ID);
 
         if (debugger.isValid())
-        DebuggerKitAspect::setDebugger(kptr, debugger);
+            DebuggerKitAspect::setDebugger(k, debugger);
 
-    DeviceTypeKitAspect::setDeviceTypeId(kptr, Constants::QNX_QNX_OS_TYPE);
+        DeviceTypeKitAspect::setDeviceTypeId(k, Constants::QNX_QNX_OS_TYPE);
         // TODO: Add sysroot?
 
-    kit->setUnexpandedDisplayName(
+        k->setUnexpandedDisplayName(
                     QCoreApplication::translate(
                         "Qnx::Internal::QnxConfiguration",
                         "Kit for %1 (%2)")
                     .arg(displayName())
                     .arg(target.shortDescription()));
 
-    kit->setAutoDetected(true);
+        k->setAutoDetected(true);
-    kit->setAutoDetectionSource(envFile().toString());
+        k->setAutoDetectionSource(envFile().toString());
-    kit->setMutable(DeviceKitAspect::id(), true);
+        k->setMutable(DeviceKitAspect::id(), true);
 
-    kit->setSticky(ToolChainKitAspect::id(), true);
+        k->setSticky(ToolChainKitAspect::id(), true);
-    kit->setSticky(DeviceTypeKitAspect::id(), true);
+        k->setSticky(DeviceTypeKitAspect::id(), true);
-    kit->setSticky(SysRootKitAspect::id(), true);
+        k->setSticky(SysRootKitAspect::id(), true);
-    kit->setSticky(DebuggerKitAspect::id(), true);
+        k->setSticky(DebuggerKitAspect::id(), true);
-    kit->setSticky(QmakeProjectManager::Constants::KIT_INFORMATION_ID, true);
+        k->setSticky(QmakeProjectManager::Constants::KIT_INFORMATION_ID, true);
+        return true;
+    };
 
     // add kit with device and qt version not sticky
-    KitManager::registerKit(std::move(kit));
+    return KitManager::registerKit(init);
-    return kptr;
 }
 
 QStringList QnxConfiguration::validationErrors() const