feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

KitManager: Use unique_ptr to manage kits

Browse Source 
Change-Id: I8c66290f0d23afe37673bd858f7db135c8232a78
Reviewed-by: Ulf Hermann <ulf.hermann@qt.io>
This commit is contained in:
Tobias Hunger
2018-07-16 15:32:23 +02:00
parent df2b2f1a17
commit f685e2bfb4
13 changed files with 151 additions and 158 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
src/plugins/android/androidconfigurations.cpp
View File

@@ -1057,17 +1057,18 @@ void AndroidConfigurations::updateAutomaticKitList()
}; };
for (const QtSupport::BaseQtVersion *qt : qtVersionsForArch.value(tc->targetAbi())) { for (const QtSupport::BaseQtVersion *qt : qtVersionsForArch.value(tc->targetAbi())) {
Kit *newKit = new Kit; auto newKit = std::make_unique<Kit>();
initBasicKitData(newKit, qt); Kit *toSetup = newKit.get();
Kit *existingKit = Utils::findOrDefault(existingKits, [newKit](const Kit *k) { initBasicKitData(toSetup, qt);
return matchKits(newKit, k); Kit *existingKit = Utils::findOrDefault(existingKits, [toSetup](const Kit *k) {
return matchKits(toSetup, k);
}); });
if (existingKit) { if (existingKit) {
// Existing kit found. // Existing kit found.
// Update the existing kit with new data. // Update the existing kit with new data.
initBasicKitData(existingKit, qt); initBasicKitData(existingKit, qt);
KitManager::deleteKit(newKit); newKit.reset();
newKit = existingKit; toSetup = existingKit;
} }
Debugger::DebuggerItem debugger; Debugger::DebuggerItem debugger;
@@ -1078,16 +1079,16 @@ void AndroidConfigurations::updateAutomaticKitList()
debugger.setAbi(tc->targetAbi()); debugger.setAbi(tc->targetAbi());
debugger.reinitializeFromFile(); debugger.reinitializeFromFile();
QVariant id = Debugger::DebuggerItemManager::registerDebugger(debugger); QVariant id = Debugger::DebuggerItemManager::registerDebugger(debugger);
Debugger::DebuggerKitInformation::setDebugger(newKit, id); Debugger::DebuggerKitInformation::setDebugger(toSetup, id);
AndroidGdbServerKitInformation::setGdbSever(newKit, tc->suggestedGdbServer()); AndroidGdbServerKitInformation::setGdbSever(toSetup, tc->suggestedGdbServer());
newKit->makeSticky(); toSetup->makeSticky();
newKit->setUnexpandedDisplayName(tr("Android for %1 (GCC %2, %3)") toSetup->setUnexpandedDisplayName(tr("Android for %1 (GCC %2, %3)")
.arg(static_cast<const AndroidQtVersion *>(qt)->targetArch()) .arg(static_cast<const AndroidQtVersion *>(qt)->targetArch())
.arg(tc->ndkToolChainVersion()) .arg(tc->ndkToolChainVersion())
.arg(qt->displayName())); .arg(qt->displayName()));
if (!existingKit) if (!existingKit)
KitManager::registerKit(newKit); KitManager::registerKit(std::move(newKit));
} }
} }
} }

11
src/plugins/ios/iosconfigurations.cpp
View File

@@ -63,6 +63,8 @@
#include <QStandardPaths> #include <QStandardPaths>
#include <QTimer> #include <QTimer>
#include <memory>
using namespace ProjectExplorer; using namespace ProjectExplorer;
using namespace QtSupport; using namespace QtSupport;
using namespace Utils; using namespace Utils;
@@ -298,7 +300,8 @@ void IosConfigurations::updateAutomaticKitList()
kit->unblockNotification(); kit->unblockNotification();
} else { } else {
qCDebug(kitSetupLog) << " - Setting up new kit"; qCDebug(kitSetupLog) << " - Setting up new kit";
kit = new Kit; auto newKit = std::make_unique<Kit>();
kit = newKit.get();
kit->blockNotification(); kit->blockNotification();
kit->setAutoDetected(true); kit->setAutoDetected(true);
const QString baseDisplayName = isSimulatorDeviceId(pDeviceType) const QString baseDisplayName = isSimulatorDeviceId(pDeviceType)
@@ -307,7 +310,7 @@ void IosConfigurations::updateAutomaticKitList()
kit->setUnexpandedDisplayName(baseDisplayName); kit->setUnexpandedDisplayName(baseDisplayName);
setupKit(kit, pDeviceType, platformToolchains, debuggerId, sdk.path, qtVersion); setupKit(kit, pDeviceType, platformToolchains, debuggerId, sdk.path, qtVersion);
kit->unblockNotification(); kit->unblockNotification();
KitManager::registerKit(kit); KitManager::registerKit(std::move(newKit));
} }
resultingKits.insert(kit); resultingKits.insert(kit);
} }
@@ -330,8 +333,8 @@ IosConfigurations *IosConfigurations::instance()
void IosConfigurations::initialize() void IosConfigurations::initialize()
{ {
QTC_CHECK(m_instance == 0); QTC_CHECK(m_instance == nullptr);
m_instance = new IosConfigurations(0); m_instance = new IosConfigurations(nullptr);
} }
bool IosConfigurations::ignoreAllDevices() bool IosConfigurations::ignoreAllDevices()

5
src/plugins/projectexplorer/kit.h
View File

@@ -61,6 +61,8 @@ public:
using Predicate = std::function<bool(const Kit *)>; using Predicate = std::function<bool(const Kit *)>;
explicit Kit(Core::Id id = Core::Id()); explicit Kit(Core::Id id = Core::Id());
explicit Kit(const QVariantMap &data);
~Kit();
// Do not trigger evaluations // Do not trigger evaluations
void blockNotification(); void blockNotification();
@@ -129,9 +131,6 @@ public:
private: private:
void setSdkProvided(bool sdkProvided); void setSdkProvided(bool sdkProvided);
~Kit();
Kit(const QVariantMap &data);
// Unimplemented. // Unimplemented.
Kit(const Kit &other); Kit(const Kit &other);
void operator=(const Kit &other); void operator=(const Kit &other);

167
src/plugins/projectexplorer/kitmanager.cpp
View File

@@ -67,21 +67,13 @@ static FileName settingsFileName()
class KitManagerPrivate class KitManagerPrivate
{ {
public: public:
~KitManagerPrivate();
Kit *m_defaultKit = nullptr; Kit *m_defaultKit = nullptr;
bool m_initialized = false; bool m_initialized = false;
std::vector<std::unique_ptr<KitInformation>> m_informationList; std::vector<std::unique_ptr<KitInformation>> m_informationList;
QList<Kit *> m_kitList; std::vector<std::unique_ptr<Kit>> m_kitList;
std::unique_ptr<PersistentSettingsWriter> m_writer; std::unique_ptr<PersistentSettingsWriter> m_writer;
}; };
KitManagerPrivate::~KitManagerPrivate()
{
foreach (Kit *k, m_kitList)
delete k;
}
} // namespace Internal } // namespace Internal
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -114,78 +106,82 @@ void KitManager::restoreKits()
{ {
QTC_ASSERT(!d->m_initialized, return ); QTC_ASSERT(!d->m_initialized, return );
QList<Kit *> resultList; std::vector<std::unique_ptr<Kit>> resultList;
// read all kits from SDK
KitList system
= restoreKits(FileName::fromString(ICore::installerResourcePath() + KIT_FILENAME));
// make sure we mark these as autodetected and run additional setup logic
for (Kit *k : system.kits) {
k->setAutoDetected(true);
k->setSdkProvided(true);
k->makeSticky();
}
// read all kits from user file // read all kits from user file
std::vector<Kit *> kitsToCheck; Core::Id defaultUserKit;
KitList userKits = restoreKits(settingsFileName()); std::vector<std::unique_ptr<Kit>> kitsToCheck;
foreach (Kit *k, userKits.kits) { {
if (k->isSdkProvided()) { KitList userKits = restoreKits(settingsFileName());
kitsToCheck.emplace_back(k); defaultUserKit = userKits.defaultKit;
} else {
completeKit(k); // Store manual kits for (auto &k : userKits.kits) {
resultList.append(k); if (k->isSdkProvided()) {
kitsToCheck.emplace_back(std::move(k));
} else {
completeKit(k.get()); // Store manual kits
resultList.emplace_back(std::move(k));
}
} }
} }
// SDK kits need to get updated with the user-provided extra settings: // read all kits from SDK
for (Kit *current : system.kits) { {
Kit *toStore = current; KitList system
toStore->upgrade(); = restoreKits(FileName::fromString(ICore::installerResourcePath() + KIT_FILENAME));
toStore->setup(); // Make sure all kitinformation are properly set up before merging them
// with the information from the user settings file
// Check whether we had this kit stored and prefer the stored one: // SDK kits need to get updated with the user-provided extra settings:
const auto i = std::find_if(std::begin(kitsToCheck), for (auto &current : system.kits) {
std::end(kitsToCheck), // make sure we mark these as autodetected and run additional setup logic
Utils::equal(&Kit::id, current->id())); current->setAutoDetected(true);
if (i != std::end(kitsToCheck)) { current->setSdkProvided(true);
toStore = *i; current->makeSticky();
kitsToCheck.erase(i);
// Overwrite settings that the SDK sets to those values: // Process:
foreach (const KitInformation *ki, kitInformation()) { auto toStore = std::move(current);
// Copy sticky settings over: toStore->upgrade();
if (current->isSticky(ki->id())) { toStore->setup(); // Make sure all kitinformation are properly set up before merging them
toStore->setValue(ki->id(), current->value(ki->id())); // with the information from the user settings file
toStore->setSticky(ki->id(), true);
// Check whether we had this kit stored and prefer the stored one:
const auto i = std::find_if(std::begin(kitsToCheck),
std::end(kitsToCheck),
Utils::equal(&Kit::id, toStore->id()));
if (i != std::end(kitsToCheck)) {
Kit *ptr = i->get();
// Overwrite settings that the SDK sets to those values:
foreach (const KitInformation *ki, KitManager::kitInformation()) {
// Copy sticky settings over:
if (ptr->isSticky(ki->id())) {
ptr->setValue(ki->id(), toStore->value(ki->id()));
ptr->setSticky(ki->id(), true);
}
} }
toStore = std::move(*i);
kitsToCheck.erase(i);
} }
completeKit(toStore.get()); // Store manual kits
delete current; resultList.emplace_back(std::move(toStore));
} }
completeKit(toStore); // Store manual kits
resultList.append(toStore);
} }
// Delete all loaded autodetected kits that were not rediscovered: // Delete all loaded autodetected kits that were not rediscovered:
foreach (Kit *k, kitsToCheck)
delete k;
kitsToCheck.clear(); kitsToCheck.clear();
if (resultList.isEmpty()) { if (resultList.size() == 0) {
Kit *defaultKit = new Kit; // One kit using default values auto defaultKit = std::make_unique<Kit>(); // One kit using default values
defaultKit->setUnexpandedDisplayName(tr("Desktop")); defaultKit->setUnexpandedDisplayName(tr("Desktop"));
defaultKit->setSdkProvided(false); defaultKit->setSdkProvided(false);
defaultKit->setAutoDetected(false); defaultKit->setAutoDetected(false);
defaultKit->setup(); defaultKit->setup();
completeKit(defaultKit); // Store manual kits completeKit(defaultKit.get()); // Store manual kits
resultList.append(defaultKit); resultList.emplace_back(std::move(defaultKit));
} }
Kit *k = Utils::findOrDefault(resultList, Utils::equal(&Kit::id, userKits.defaultKit)); Kit *k = Utils::findOrDefault(resultList, Utils::equal(&Kit::id, defaultUserKit));
if (!k) if (!k)
k = Utils::findOrDefault(resultList, &Kit::isValid); k = Utils::findOrDefault(resultList, &Kit::isValid);
std::swap(resultList, d->m_kitList); std::swap(resultList, d->m_kitList);
@@ -323,12 +319,10 @@ KitManager::KitList KitManager::restoreKits(const FileName &fileName)
const QVariantMap stMap = data.value(key).toMap(); const QVariantMap stMap = data.value(key).toMap();
auto *k = new Kit(stMap); auto k = std::make_unique<Kit>(stMap);
if (k->id().isValid()) { if (k->id().isValid()) {
result.kits.append(k); result.kits.emplace_back(std::move(k));
} else { } else {
// If the Id is broken, then do not trust the rest of the data either.
delete k;
qWarning("Warning: Unable to restore kits stored in %s at position %d.", qWarning("Warning: Unable to restore kits stored in %s at position %d.",
qPrintable(fileName.toUserOutput()), qPrintable(fileName.toUserOutput()),
i); i);
@@ -338,21 +332,19 @@ KitManager::KitList KitManager::restoreKits(const FileName &fileName)
if (!id.isValid()) if (!id.isValid())
return result; return result;
foreach (Kit *k, result.kits) { if (Utils::contains(result.kits, [id](const std::unique_ptr<Kit> &k) { return k->id() == id; }))
if (k->id() == id) { result.defaultKit = id;
result.defaultKit = id;
break;
}
}
return result; return result;
} }
QList<Kit *> KitManager::kits(const Kit::Predicate &predicate) QList<Kit *> KitManager::kits(const Kit::Predicate &predicate)
{ {
const QList<Kit *> result = Utils::toRawPointer<QList>(d->m_kitList);
if (predicate) if (predicate)
return Utils::filtered(d->m_kitList, predicate); return Utils::filtered(result, predicate);
return d->m_kitList; return result;
} }
Kit *KitManager::kit(Id id) Kit *KitManager::kit(Id id)
{ {
@@ -364,7 +356,7 @@ Kit *KitManager::kit(Id id)
Kit *KitManager::kit(const Kit::Predicate &predicate) Kit *KitManager::kit(const Kit::Predicate &predicate)
{ {
return Utils::findOrDefault(d->m_kitList, predicate); return Utils::findOrDefault(kits(), predicate);
} }
Kit *KitManager::defaultKit() Kit *KitManager::defaultKit()
@@ -388,24 +380,18 @@ KitManagerConfigWidget *KitManager::createConfigWidget(Kit *k)
return result; return result;
} }
void KitManager::deleteKit(Kit *k)
{
QTC_ASSERT(!KitManager::kits().contains(k), return );
delete k;
}
void KitManager::notifyAboutUpdate(Kit *k) void KitManager::notifyAboutUpdate(Kit *k)
{ {
if (!k || !isLoaded()) if (!k || !isLoaded())
return; return;
if (d->m_kitList.contains(k)) if (Utils::contains(d->m_kitList, k))
emit m_instance->kitUpdated(k); emit m_instance->kitUpdated(k);
else else
emit m_instance->unmanagedKitUpdated(k); emit m_instance->unmanagedKitUpdated(k);
} }
bool KitManager::registerKit(Kit *k) bool KitManager::registerKit(std::unique_ptr<Kit> &&k)
{ {
QTC_ASSERT(isLoaded(), return false); QTC_ASSERT(isLoaded(), return false);
@@ -414,38 +400,39 @@ bool KitManager::registerKit(Kit *k)
QTC_ASSERT(k->id().isValid(), return false); QTC_ASSERT(k->id().isValid(), return false);
if (kits().contains(k)) Kit *kptr = k.get();
if (Utils::contains(d->m_kitList, kptr))
return false; return false;
// make sure we have all the information in our kits: // make sure we have all the information in our kits:
completeKit(k); completeKit(kptr);
d->m_kitList.append(k);
if (!d->m_defaultKit || (!d->m_defaultKit->isValid() && k->isValid())) d->m_kitList.emplace_back(std::move(k));
setDefaultKit(k);
emit m_instance->kitAdded(k); if (!d->m_defaultKit || (!d->m_defaultKit->isValid() && kptr->isValid()))
setDefaultKit(kptr);
emit m_instance->kitAdded(kptr);
return true; return true;
} }
void KitManager::deregisterKit(Kit *k) void KitManager::deregisterKit(Kit *k)
{ {
if (!k || !kits().contains(k)) if (!k || !Utils::contains(d->m_kitList, k))
return; return;
d->m_kitList.removeOne(k); auto taken = Utils::take(d->m_kitList, k);
if (defaultKit() == k) { if (defaultKit() == k) {
Kit *newDefault = Utils::findOrDefault(kits(), [](Kit *k) { return k->isValid(); }); Kit *newDefault = Utils::findOrDefault(kits(), [](Kit *k) { return k->isValid(); });
setDefaultKit(newDefault); setDefaultKit(newDefault);
} }
emit m_instance->kitRemoved(k); emit m_instance->kitRemoved(k);
delete k;
} }
void KitManager::setDefaultKit(Kit *k) void KitManager::setDefaultKit(Kit *k)
{ {
if (defaultKit() == k) if (defaultKit() == k)
return; return;
if (k && !kits().contains(k)) if (k && !Utils::contains(d->m_kitList, k))
return; return;
d->m_defaultKit = k; d->m_defaultKit = k;
emit m_instance->defaultkitChanged(); emit m_instance->defaultkitChanged();

6
src/plugins/projectexplorer/kitmanager.h
View File

@@ -124,9 +124,7 @@ public:
static Internal::KitManagerConfigWidget *createConfigWidget(Kit *k); static Internal::KitManagerConfigWidget *createConfigWidget(Kit *k);
static void deleteKit(Kit *k); static bool registerKit(std::unique_ptr<Kit> &&k);
static bool registerKit(Kit *k);
static void deregisterKit(Kit *k); static void deregisterKit(Kit *k);
static void setDefaultKit(Kit *k); static void setDefaultKit(Kit *k);
@@ -171,7 +169,7 @@ private:
public: public:
KitList() {} KitList() {}
Core::Id defaultKit; Core::Id defaultKit;
QList<Kit *> kits; std::vector<std::unique_ptr<Kit>> kits;
}; };
KitList restoreKits(const Utils::FileName &fileName); KitList restoreKits(const Utils::FileName &fileName);

21
src/plugins/projectexplorer/kitmanagerconfigwidget.cpp
View File

@@ -32,6 +32,7 @@
#include <coreplugin/variablechooser.h> #include <coreplugin/variablechooser.h>
#include <utils/algorithm.h>
#include <utils/detailswidget.h> #include <utils/detailswidget.h>
#include <utils/qtcassert.h> #include <utils/qtcassert.h>
#include <utils/macroexpander.h> #include <utils/macroexpander.h>
@@ -60,7 +61,7 @@ KitManagerConfigWidget::KitManagerConfigWidget(Kit *k) :
m_nameEdit(new QLineEdit), m_nameEdit(new QLineEdit),
m_fileSystemFriendlyNameLineEdit(new QLineEdit), m_fileSystemFriendlyNameLineEdit(new QLineEdit),
m_kit(k), m_kit(k),
m_modifiedKit(new Kit(Core::Id(WORKING_COPY_KIT_ID))) m_modifiedKit(std::make_unique<Kit>(Core::Id(WORKING_COPY_KIT_ID)))
{ {
static auto alignment static auto alignment
= static_cast<const Qt::Alignment>(style()->styleHint(QStyle::SH_FormLayoutLabelAlignment)); = static_cast<const Qt::Alignment>(style()->styleHint(QStyle::SH_FormLayoutLabelAlignment));
@@ -129,10 +130,9 @@ KitManagerConfigWidget::~KitManagerConfigWidget()
qDeleteAll(m_actions); qDeleteAll(m_actions);
m_actions.clear(); m_actions.clear();
KitManager::deleteKit(m_modifiedKit);
// Make sure our workingCopy did not get registered somehow: // Make sure our workingCopy did not get registered somehow:
foreach (const Kit *k, KitManager::kits()) QTC_CHECK(!Utils::contains(KitManager::kits(),
QTC_CHECK(k->id() != Core::Id(WORKING_COPY_KIT_ID)); Utils::equal(&Kit::id, Core::Id(WORKING_COPY_KIT_ID))));
} }
QString KitManagerConfigWidget::displayName() const QString KitManagerConfigWidget::displayName() const
@@ -151,13 +151,14 @@ void KitManagerConfigWidget::apply()
{ {
bool mustSetDefault = m_isDefaultKit; bool mustSetDefault = m_isDefaultKit;
bool mustRegister = false; bool mustRegister = false;
auto toRegister = std::make_unique<Kit>();
if (!m_kit) { if (!m_kit) {
mustRegister = true; mustRegister = true;
m_kit = new Kit; m_kit = toRegister.get();
} }
m_kit->copyFrom(m_modifiedKit); //m_isDefaultKit is reset in discard() here. m_kit->copyFrom(m_modifiedKit.get()); //m_isDefaultKit is reset in discard() here.
if (mustRegister) if (mustRegister)
KitManager::registerKit(m_kit); KitManager::registerKit(std::move(toRegister));
if (mustSetDefault) if (mustSetDefault)
KitManager::setDefaultKit(m_kit); KitManager::setDefaultKit(m_kit);
@@ -186,7 +187,7 @@ void KitManagerConfigWidget::discard()
bool KitManagerConfigWidget::isDirty() const bool KitManagerConfigWidget::isDirty() const
{ {
return !m_kit return !m_kit
|| !m_kit->isEqual(m_modifiedKit) || !m_kit->isEqual(m_modifiedKit.get())
|| m_isDefaultKit != (KitManager::defaultKit() == m_kit); || m_isDefaultKit != (KitManager::defaultKit() == m_kit);
} }
@@ -272,7 +273,7 @@ void KitManagerConfigWidget::makeStickySubWidgetsReadOnly()
Kit *KitManagerConfigWidget::workingCopy() const Kit *KitManagerConfigWidget::workingCopy() const
{ {
return m_modifiedKit; return m_modifiedKit.get();
} }
bool KitManagerConfigWidget::configures(Kit *k) const bool KitManagerConfigWidget::configures(Kit *k) const
@@ -340,7 +341,7 @@ void KitManagerConfigWidget::setFileSystemFriendlyName()
void KitManagerConfigWidget::workingCopyWasUpdated(Kit *k) void KitManagerConfigWidget::workingCopyWasUpdated(Kit *k)
{ {
if (k != m_modifiedKit || m_fixingKit) if (k != m_modifiedKit.get() || m_fixingKit)
return; return;
m_fixingKit = true; m_fixingKit = true;

4
src/plugins/projectexplorer/kitmanagerconfigwidget.h
View File

@@ -29,6 +29,8 @@
#include <QWidget> #include <QWidget>
#include <memory>
QT_BEGIN_NAMESPACE QT_BEGIN_NAMESPACE
class QGridLayout; class QGridLayout;
class QLabel; class QLabel;
@@ -98,7 +100,7 @@ private:
QList<KitConfigWidget *> m_widgets; QList<KitConfigWidget *> m_widgets;
QList<QLabel *> m_labels; QList<QLabel *> m_labels;
Kit *m_kit; Kit *m_kit;
Kit *m_modifiedKit; std::unique_ptr<Kit> m_modifiedKit;
bool m_isDefaultKit = false; bool m_isDefaultKit = false;
bool m_fixingKit = false; bool m_fixingKit = false;
bool m_hasUniqueName = true; bool m_hasUniqueName = true;

19
src/plugins/projectexplorer/projectimporter.cpp
View File

@@ -286,26 +286,27 @@ bool ProjectImporter::isTemporaryKit(Kit *k) const
Kit *ProjectImporter::createTemporaryKit(const KitSetupFunction &setup) const Kit *ProjectImporter::createTemporaryKit(const KitSetupFunction &setup) const
{ {
Kit *k = new Kit; auto k = std::make_unique<Kit>();
Kit *kptr = k.get();
UpdateGuard guard(*this); UpdateGuard guard(*this);
{ {
KitGuard kitGuard(k); KitGuard kitGuard(kptr);
k->setUnexpandedDisplayName(QCoreApplication::translate("ProjectExplorer::ProjectImporter", "Imported Kit"));; k->setUnexpandedDisplayName(QCoreApplication::translate("ProjectExplorer::ProjectImporter", "Imported Kit"));;
// Set up values: // Set up values:
foreach (KitInformation *ki, KitManager::kitInformation()) foreach (KitInformation *ki, KitManager::kitInformation())
ki->setup(k); ki->setup(kptr);
setup(k); setup(kptr);
foreach (KitInformation *ki, KitManager::kitInformation()) foreach (KitInformation *ki, KitManager::kitInformation())
ki->fix(k); ki->fix(kptr);
markKitAsTemporary(k); markKitAsTemporary(kptr);
addProject(k); addProject(kptr);
} // ~KitGuard, sending kitUpdated } // ~KitGuard, sending kitUpdated
KitManager::registerKit(k); // potentially adds kits to other targetsetuppages KitManager::registerKit(std::move(k)); // potentially adds kits to other targetsetuppages
return k; return kptr;
} }
bool ProjectImporter::findTemporaryHandler(Core::Id id) const bool ProjectImporter::findTemporaryHandler(Core::Id id) const

9
src/plugins/qmlprofiler/tests/qmlprofilerattachdialog_test.cpp
View File

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

7
src/plugins/qmlprofiler/tests/qmlprofilerdetailsrewriter_test.cpp
View File

@@ -229,9 +229,9 @@ void QmlProfilerDetailsRewriterTest::seedRewriter()
doc->parse(); doc->parse();
QVERIFY(!doc->source().isEmpty()); QVERIFY(!doc->source().isEmpty());
ProjectExplorer::Kit *kit = new ProjectExplorer::Kit; auto kit = std::make_unique<ProjectExplorer::Kit>();
ProjectExplorer::SysRootKitInformation::setSysRoot( ProjectExplorer::SysRootKitInformation::setSysRoot(
kit, Utils::FileName::fromLatin1("/nowhere")); kit.get(), Utils::FileName::fromLatin1("/nowhere"));
DummyProject *project = new DummyProject(Utils::FileName::fromString(filename)); DummyProject *project = new DummyProject(Utils::FileName::fromString(filename));
ProjectExplorer::SessionManager::addProject(project); ProjectExplorer::SessionManager::addProject(project);
@@ -240,12 +240,11 @@ void QmlProfilerDetailsRewriterTest::seedRewriter()
// Make sure the uniqe_ptr gets deleted before the project. // Make sure the uniqe_ptr gets deleted before the project.
// Otherwise we'll get a double free because the target is also parented to the project // Otherwise we'll get a double free because the target is also parented to the project
// and unique_ptr doesn't know anything about QObject parent/child relationships. // and unique_ptr doesn't know anything about QObject parent/child relationships.
std::unique_ptr<ProjectExplorer::Target> target = project->createTarget(kit); std::unique_ptr<ProjectExplorer::Target> target = project->createTarget(kit.get());
m_rewriter.populateFileFinder(target.get()); m_rewriter.populateFileFinder(target.get());
} }
ProjectExplorer::SessionManager::removeProject(project); ProjectExplorer::SessionManager::removeProject(project);
ProjectExplorer::KitManager::deleteKit(kit);
} }
} // namespace Internal } // namespace Internal

7
src/plugins/qmlprofiler/tests/qmlprofilertool_test.cpp
View File

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

19
src/plugins/qnx/qnxconfiguration.cpp
View File

@@ -300,18 +300,19 @@ ProjectExplorer::Kit *QnxConfiguration::createKit(
QnxQtVersion *qnxQt = qnxQtVersion(target); QnxQtVersion *qnxQt = qnxQtVersion(target);
// Do not create incomplete kits if no qt qnx version found // Do not create incomplete kits if no qt qnx version found
if (!qnxQt) if (!qnxQt)
return 0; return nullptr;
Kit *kit = new Kit; auto kit = std::make_unique<Kit>();
Kit *kptr = kit.get();
QtKitInformation::setQtVersion(kit, qnxQt); QtKitInformation::setQtVersion(kptr, qnxQt);
ToolChainKitInformation::setToolChain(kit, toolChain); ToolChainKitInformation::setToolChain(kptr, toolChain);
ToolChainKitInformation::clearToolChain(kit, ProjectExplorer::Constants::C_LANGUAGE_ID); ToolChainKitInformation::clearToolChain(kptr, ProjectExplorer::Constants::C_LANGUAGE_ID);
if (debugger.isValid()) if (debugger.isValid())
DebuggerKitInformation::setDebugger(kit, debugger); DebuggerKitInformation::setDebugger(kptr, debugger);
DeviceTypeKitInformation::setDeviceTypeId(kit, Constants::QNX_QNX_OS_TYPE); DeviceTypeKitInformation::setDeviceTypeId(kptr, Constants::QNX_QNX_OS_TYPE);
// TODO: Add sysroot? // TODO: Add sysroot?
kit->setUnexpandedDisplayName( kit->setUnexpandedDisplayName(
@@ -332,8 +333,8 @@ ProjectExplorer::Kit *QnxConfiguration::createKit(
kit->setSticky(QmakeProjectManager::Constants::KIT_INFORMATION_ID, true); kit->setSticky(QmakeProjectManager::Constants::KIT_INFORMATION_ID, true);
// add kit with device and qt version not sticky // add kit with device and qt version not sticky
KitManager::registerKit(kit); KitManager::registerKit(std::move(kit));
return kit; return kptr;
} }
QStringList QnxConfiguration::validationErrors() const QStringList QnxConfiguration::validationErrors() const

5
src/plugins/qtsupport/qtprojectimporter.cpp
View File

@@ -589,7 +589,7 @@ void QtSupportPlugin::testQtProjectImporter_oneProject()
} }
if (templateKit != defaultKit) if (templateKit != defaultKit)
KitManager::deleteKit(templateKit); delete templateKit;
} }
// -------------------------------------------------------------------- // --------------------------------------------------------------------
@@ -603,8 +603,7 @@ void QtSupportPlugin::testQtProjectImporter_oneProject()
KitManager::deregisterKit(k); KitManager::deregisterKit(k);
// Delete kit templates: // Delete kit templates:
for (int i = 1; i < kitTemplates.count(); ++i) qDeleteAll(kitTemplates);
KitManager::deleteKit(kitTemplates.at(i));
} }
} // namespace Internal } // namespace Internal