Make DeployConfigurationFactory more similar to RunConfigFactories

This follows some of the recent changes to RunConfigurations:
- pass Id from factory to DeployConfiguration constructors
- de-object-ify DeployConfigurationFactory
- use addSupportedTargetDeviceType(Id) instead of
  addSupportedTargetDeviceType(List<Id>)

Also, use stepList()->appendStep() instead of stepList()->insertStep(pos...)
with manual pos tracking in some cases.

Change-Id: I09c6a9d0f66f9f85b1c13361104f7878028e1ea8
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>

src/plugins/android/androiddeployconfiguration.cpp

@@ -44,23 +44,20 @@ using namespace ProjectExplorer;
 namespace Android {
 namespace Internal {
 
-// Qt 5.2 has a new form of deployment
+AndroidDeployConfiguration::AndroidDeployConfiguration(Target *parent, Core::Id id)
-const char ANDROID_DEPLOYCONFIGURATION_ID[] = "Qt4ProjectManager.AndroidDeployConfiguration2";
+    : DeployConfiguration(parent, id)
-
-AndroidDeployConfiguration::AndroidDeployConfiguration(Target *parent)
-    : DeployConfiguration(parent, ANDROID_DEPLOYCONFIGURATION_ID)
 {}
 
 void AndroidDeployConfiguration::initialize()
 {
-    stepList()->insertStep(0, new AndroidDeployQtStep(stepList()));
+    stepList()->appendStep(new AndroidDeployQtStep(stepList()));
 }
 
 AndroidDeployConfigurationFactory::AndroidDeployConfigurationFactory()
 {
-    setObjectName("AndroidDeployConfigurationFactory");
+    registerDeployConfiguration<AndroidDeployConfiguration>
-    registerDeployConfiguration<AndroidDeployConfiguration>(ANDROID_DEPLOYCONFIGURATION_ID);
+            ("Qt4ProjectManager.AndroidDeployConfiguration2");
-    setSupportedTargetDeviceTypes({Constants::ANDROID_DEVICE_TYPE});
+    addSupportedTargetDeviceType(Constants::ANDROID_DEVICE_TYPE);
     setDefaultDisplayName(AndroidDeployConfiguration::tr("Deploy to Android device"));
 }
 

src/plugins/android/androiddeployconfiguration.h

@@ -35,14 +35,12 @@ class AndroidDeployConfiguration : public ProjectExplorer::DeployConfiguration
     Q_OBJECT
 
 public:
-    explicit AndroidDeployConfiguration(ProjectExplorer::Target *parent);
+    AndroidDeployConfiguration(ProjectExplorer::Target *parent, Core::Id id);
     void initialize() override;
 };
 
 class AndroidDeployConfigurationFactory : public ProjectExplorer::DeployConfigurationFactory
 {
-    Q_OBJECT
-
 public:
     AndroidDeployConfigurationFactory();
 

src/plugins/ios/iosdeployconfiguration.cpp

@@ -30,7 +30,6 @@
 #include <projectexplorer/buildsteplist.h>
 #include <projectexplorer/target.h>
 
-#include <qmakeprojectmanager/qmakeproject.h>
 #include <qmakeprojectmanager/qmakeprojectmanagerconstants.h>
 
 using namespace ProjectExplorer;
@@ -38,25 +37,23 @@ using namespace ProjectExplorer;
 namespace Ios {
 namespace Internal {
 
-const char IOS_DEPLOYCONFIGURATION_ID[] = "Qt4ProjectManager.IosDeployConfiguration";
+IosDeployConfiguration::IosDeployConfiguration(Target *parent, Core::Id id)
-
+    : DeployConfiguration(parent, id)
-IosDeployConfiguration::IosDeployConfiguration(Target *parent)
-    : DeployConfiguration(parent, IOS_DEPLOYCONFIGURATION_ID)
 {
 }
 
 void IosDeployConfiguration::initialize()
 {
-    stepList()->insertStep(0, new IosDeployStep(stepList()));
+    stepList()->appendStep(new IosDeployStep(stepList()));
 }
 
 IosDeployConfigurationFactory::IosDeployConfigurationFactory()
 {
-    setObjectName("IosDeployConfigurationFactory");
+    registerDeployConfiguration<IosDeployConfiguration>("Qt4ProjectManager.IosDeployConfiguration");
-    registerDeployConfiguration<IosDeployConfiguration>(IOS_DEPLOYCONFIGURATION_ID);
     setSupportedProjectType(QmakeProjectManager::Constants::QMAKEPROJECT_ID);
-    setSupportedTargetDeviceTypes({Constants::IOS_DEVICE_TYPE, Constants::IOS_SIMULATOR_TYPE});
+    addSupportedTargetDeviceType(Constants::IOS_DEVICE_TYPE);
-    setDefaultDisplayName(tr("Deploy on iOS"));
+    addSupportedTargetDeviceType(Constants::IOS_SIMULATOR_TYPE);
+    setDefaultDisplayName(IosDeployConfiguration::tr("Deploy on iOS"));
 }
 
 } // namespace Internal

src/plugins/ios/iosdeployconfiguration.h

@@ -35,14 +35,12 @@ class IosDeployConfiguration : public ProjectExplorer::DeployConfiguration
     Q_OBJECT
 
 public:
-    explicit IosDeployConfiguration(ProjectExplorer::Target *parent);
+    IosDeployConfiguration(ProjectExplorer::Target *parent, Core::Id id);
     void initialize() override;
 };
 
 class IosDeployConfigurationFactory : public ProjectExplorer::DeployConfigurationFactory
 {
-    Q_OBJECT
-
 public:
     IosDeployConfigurationFactory();
 };

src/plugins/projectexplorer/deployconfiguration.cpp

@@ -38,7 +38,6 @@ namespace ProjectExplorer {
 
 const char BUILD_STEP_LIST_COUNT[] = "ProjectExplorer.BuildConfiguration.BuildStepListCount";
 const char BUILD_STEP_LIST_PREFIX[] = "ProjectExplorer.BuildConfiguration.BuildStepList.";
-const char DEFAULT_DEPLOYCONFIGURATION_ID[] = "ProjectExplorer.DefaultDeployConfiguration";
 
 DeployConfiguration::DeployConfiguration(Target *target, Core::Id id)
     : ProjectConfiguration(target, id),
@@ -144,7 +143,6 @@ static QList<DeployConfigurationFactory *> g_deployConfigurationFactories;
 
 DeployConfigurationFactory::DeployConfigurationFactory()
 {
-    setObjectName("DeployConfigurationFactory");
     g_deployConfigurationFactories.append(this);
 }
 
@@ -252,9 +250,9 @@ QList<DeployConfigurationFactory *> DeployConfigurationFactory::find(Target *par
         });
 }
 
-void DeployConfigurationFactory::setSupportedTargetDeviceTypes(const QList<Core::Id> &ids)
+void DeployConfigurationFactory::addSupportedTargetDeviceType(Core::Id id)
 {
-    m_supportedTargetDeviceTypes = ids;
+    m_supportedTargetDeviceTypes.append(id);
 }
 
 void DeployConfigurationFactory::setDefaultDisplayName(const QString &defaultDisplayName)
@@ -273,17 +271,10 @@ void DeployConfigurationFactory::setSupportedProjectType(Core::Id id)
 
 DefaultDeployConfigurationFactory::DefaultDeployConfigurationFactory()
 {
-    struct DefaultDeployConfiguration : DeployConfiguration
+    registerDeployConfiguration<DeployConfiguration>("ProjectExplorer.DefaultDeployConfiguration");
-    {
+    addSupportedTargetDeviceType(Constants::DESKTOP_DEVICE_TYPE);
-        DefaultDeployConfiguration(Target *t)
-            : DeployConfiguration(t, DEFAULT_DEPLOYCONFIGURATION_ID)
-        {}
-    };
-
-    registerDeployConfiguration<DefaultDeployConfiguration>(DEFAULT_DEPLOYCONFIGURATION_ID);
-    setSupportedTargetDeviceTypes({Constants::DESKTOP_DEVICE_TYPE});
     //: Display name of the default deploy configuration
-    setDefaultDisplayName(DeployConfigurationFactory::tr("Deploy Configuration"));
+    setDefaultDisplayName(DeployConfiguration::tr("Deploy Configuration"));
 }
 
 bool DefaultDeployConfigurationFactory::canHandle(Target *parent) const

src/plugins/projectexplorer/deployconfiguration.h

@@ -72,13 +72,11 @@ private:
     BuildStepList m_stepList;
 };
 
-class PROJECTEXPLORER_EXPORT DeployConfigurationFactory : public QObject
+class PROJECTEXPLORER_EXPORT DeployConfigurationFactory
 {
-    Q_OBJECT
-
 public:
     DeployConfigurationFactory();
-    ~DeployConfigurationFactory();
+    virtual ~DeployConfigurationFactory();
 
     // used to show the list of possible additons to a target, returns a list of types
     QList<Core::Id> availableCreationIds(Target *parent) const;
@@ -92,7 +90,7 @@ public:
     static DeployConfiguration *restore(Target *parent, const QVariantMap &map);
     static DeployConfiguration *clone(Target *parent, const DeployConfiguration *dc);
 
-    void setSupportedTargetDeviceTypes(const QList<Core::Id> &ids);
+    void addSupportedTargetDeviceType(Core::Id id);
     void setDefaultDisplayName(const QString &defaultDisplayName);
     void setSupportedProjectType(Core::Id id);
 
@@ -106,8 +104,8 @@ protected:
     template <class DeployConfig>
     void registerDeployConfiguration(Core::Id deployConfigBaseId)
     {
-        m_creator = [this](Target *t) {
+        m_creator = [this, deployConfigBaseId](Target *t) {
-            auto dc = new DeployConfig(t);
+            auto dc = new DeployConfig(t, deployConfigBaseId);
             dc->setDefaultDisplayName(m_defaultDisplayName);
             return dc;
         };
@@ -115,6 +113,9 @@ protected:
     }
 
 private:
+    DeployConfigurationFactory(const DeployConfigurationFactory &) = delete;
+    DeployConfigurationFactory operator=(const DeployConfigurationFactory &) = delete;
+
     DeployConfigurationCreator m_creator;
     Core::Id m_deployConfigBaseId;
     Core::Id m_supportedProjectType;

src/plugins/qbsprojectmanager/qbsdeployconfigurationfactory.cpp

@@ -35,18 +35,15 @@
 namespace QbsProjectManager {
 namespace Internal {
 
-const char QBS_DEPLOYCONFIG_ID[] = "Qbs.Deploy";
+QbsDeployConfiguration::QbsDeployConfiguration(ProjectExplorer::Target *target, Core::Id id) :
-
+    ProjectExplorer::DeployConfiguration(target, id)
-QbsDeployConfiguration::QbsDeployConfiguration(ProjectExplorer::Target *target) :
-    ProjectExplorer::DeployConfiguration(target, QBS_DEPLOYCONFIG_ID)
 {
 }
 
 QbsDeployConfigurationFactory::QbsDeployConfigurationFactory()
 {
-    setObjectName("QbsDeployConfiguration");
+    registerDeployConfiguration<QbsDeployConfiguration>("Qbs.Deploy");
-    registerDeployConfiguration<QbsDeployConfiguration>(QBS_DEPLOYCONFIG_ID);
+    addSupportedTargetDeviceType(ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE);
-    setSupportedTargetDeviceTypes({ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE});
     setSupportedProjectType(Constants::PROJECT_ID);
     setDefaultDisplayName(QCoreApplication::translate("Qbs", "Qbs Install"));
 }

src/plugins/qbsprojectmanager/qbsdeployconfigurationfactory.h

@@ -35,13 +35,11 @@ class QbsDeployConfiguration : public ProjectExplorer::DeployConfiguration
     Q_OBJECT
 
 public:
-    explicit QbsDeployConfiguration(ProjectExplorer::Target *target);
+    QbsDeployConfiguration(ProjectExplorer::Target *target, Core::Id id);
 };
 
 class QbsDeployConfigurationFactory : public ProjectExplorer::DeployConfigurationFactory
 {
-    Q_OBJECT
-
 public:
     QbsDeployConfigurationFactory();
 };

src/plugins/qnx/qnxconstants.h

@@ -37,8 +37,6 @@ const char QNX_QNX_QT[] = "Qt4ProjectManager.QtVersion.QNX.QNX";
 
 const char QNX_QNX_FEATURE[] = "QtSupport.Wizards.FeatureQNX";
 
-const char QNX_QNX_DEPLOYCONFIGURATION_ID[] = "Qt4ProjectManager.QNX.QNXDeployConfiguration";
-
 const char QNX_QNX_RUNCONFIGURATION_PREFIX[] = "Qt4ProjectManager.QNX.QNXRunConfiguration.";
 
 const char QNX_QNX_OS_TYPE[] = "QnxOsType";

src/plugins/qnx/qnxdeployconfiguration.cpp

@@ -40,8 +40,8 @@ using namespace RemoteLinux;
 namespace Qnx {
 namespace Internal {
 
-QnxDeployConfiguration::QnxDeployConfiguration(Target *target)
+QnxDeployConfiguration::QnxDeployConfiguration(Target *target, Core::Id id)
-    : DeployConfiguration(target, Constants::QNX_QNX_DEPLOYCONFIGURATION_ID)
+    : DeployConfiguration(target, id)
 {
 }
 
@@ -59,9 +59,10 @@ NamedWidget *QnxDeployConfiguration::createConfigWidget()
 
 QnxDeployConfigurationFactory::QnxDeployConfigurationFactory()
 {
-    registerDeployConfiguration<QnxDeployConfiguration>(Constants::QNX_QNX_DEPLOYCONFIGURATION_ID);
+    registerDeployConfiguration<QnxDeployConfiguration>
-    setDefaultDisplayName(tr("Deploy to QNX Device"));
+            ("Qt4ProjectManager.QNX.QNXDeployConfiguration");
-    setSupportedTargetDeviceTypes({QnxDeviceFactory::deviceType()});
+    setDefaultDisplayName(QnxDeployConfiguration::tr("Deploy to QNX Device"));
+    addSupportedTargetDeviceType(QnxDeviceFactory::deviceType());
 }
 
 } // namespace Internal

src/plugins/qnx/qnxdeployconfiguration.h

@@ -35,15 +35,13 @@ class QnxDeployConfiguration : public ProjectExplorer::DeployConfiguration
     Q_OBJECT
 
 public:
-    explicit QnxDeployConfiguration(ProjectExplorer::Target *target);
+    QnxDeployConfiguration(ProjectExplorer::Target *target, Core::Id id);
     void initialize() override;
     ProjectExplorer::NamedWidget *createConfigWidget() override;
 };
 
-
 class QnxDeployConfigurationFactory : public ProjectExplorer::DeployConfigurationFactory
 {
-    Q_OBJECT
 public:
     QnxDeployConfigurationFactory();
 };

src/plugins/remotelinux/remotelinuxdeployconfiguration.cpp

@@ -43,15 +43,15 @@ namespace RemoteLinux {
 
 using namespace Internal;
 
-RemoteLinuxDeployConfiguration::RemoteLinuxDeployConfiguration(Target *target)
+RemoteLinuxDeployConfiguration::RemoteLinuxDeployConfiguration(Target *target, Core::Id id)
-    : DeployConfiguration(target, genericDeployConfigurationId())
+    : DeployConfiguration(target, id)
 {}
 
 void RemoteLinuxDeployConfiguration::initialize()
 {
-    stepList()->insertStep(0, new RemoteLinuxCheckForFreeDiskSpaceStep(stepList()));
+    stepList()->appendStep(new RemoteLinuxCheckForFreeDiskSpaceStep(stepList()));
-    stepList()->insertStep(1, new RemoteLinuxKillAppStep(stepList()));
+    stepList()->appendStep(new RemoteLinuxKillAppStep(stepList()));
-    stepList()->insertStep(2, new GenericDirectUploadStep(stepList()));
+    stepList()->appendStep(new GenericDirectUploadStep(stepList()));
 }
 
 NamedWidget *RemoteLinuxDeployConfiguration::createConfigWidget()
@@ -68,10 +68,9 @@ namespace Internal {
 
 RemoteLinuxDeployConfigurationFactory::RemoteLinuxDeployConfigurationFactory()
 {
-    setObjectName("RemoteLinuxDeployConfiguration");
     registerDeployConfiguration<RemoteLinuxDeployConfiguration>
             (RemoteLinuxDeployConfiguration::genericDeployConfigurationId());
-    setSupportedTargetDeviceTypes({RemoteLinux::Constants::GenericLinuxOsType});
+    addSupportedTargetDeviceType(RemoteLinux::Constants::GenericLinuxOsType);
     setDefaultDisplayName(QCoreApplication::translate("RemoteLinux",
                                                       "Deploy to Remote Linux Host"));
 }

src/plugins/remotelinux/remotelinuxdeployconfiguration.h

@@ -38,7 +38,7 @@ class REMOTELINUX_EXPORT RemoteLinuxDeployConfiguration
     Q_OBJECT
 
 public:
-    explicit RemoteLinuxDeployConfiguration(ProjectExplorer::Target *target);
+    RemoteLinuxDeployConfiguration(ProjectExplorer::Target *target, Core::Id id);
 
     static Core::Id genericDeployConfigurationId();
 
@@ -63,8 +63,6 @@ namespace Internal {
 
 class RemoteLinuxDeployConfigurationFactory : public ProjectExplorer::DeployConfigurationFactory
 {
-    Q_OBJECT
-
 public:
     RemoteLinuxDeployConfigurationFactory();
 };

src/plugins/winrt/winrtdeployconfiguration.cpp

@@ -39,50 +39,46 @@ using namespace ProjectExplorer;
 namespace WinRt {
 namespace Internal {
 
-const char appxDeployConfigurationC[] = "WinRTAppxDeployConfiguration";
-const char phoneDeployConfigurationC[] = "WinRTPhoneDeployConfiguration";
-const char emulatorDeployConfigurationC[] = "WinRTEmulatorDeployConfiguration";
-
 struct WinRtAppDeployConfiguration : DeployConfiguration
 {
-    WinRtAppDeployConfiguration(Target *target) : DeployConfiguration(target, appxDeployConfigurationC) {}
+    WinRtAppDeployConfiguration(Target *target, Core::Id id) : DeployConfiguration(target, id) {}
     void initialize() { stepList()->appendStep(new WinRtPackageDeploymentStep(stepList())); }
 };
 
 WinRtAppDeployConfigurationFactory::WinRtAppDeployConfigurationFactory()
 {
-    registerDeployConfiguration<WinRtAppDeployConfiguration>(appxDeployConfigurationC);
+    registerDeployConfiguration<WinRtAppDeployConfiguration>("WinRTAppxDeployConfiguration");
     setDefaultDisplayName(QCoreApplication::translate("WinRt::Internal::WinRtDeployConfiguration",
                                                       "Run windeployqt"));
-    setSupportedTargetDeviceTypes({Constants::WINRT_DEVICE_TYPE_LOCAL});
+    addSupportedTargetDeviceType(Constants::WINRT_DEVICE_TYPE_LOCAL);
 }
 
 struct WinRtPhoneDeployConfiguration : DeployConfiguration
 {
-    WinRtPhoneDeployConfiguration(Target *target) : DeployConfiguration(target, phoneDeployConfigurationC) {}
+    WinRtPhoneDeployConfiguration(Target *target, Core::Id id) : DeployConfiguration(target, id) {}
     void initialize() { stepList()->appendStep(new WinRtPackageDeploymentStep(stepList())); }
 };
 
 WinRtPhoneDeployConfigurationFactory::WinRtPhoneDeployConfigurationFactory()
 {
-    registerDeployConfiguration<WinRtPhoneDeployConfiguration>(phoneDeployConfigurationC);
+    registerDeployConfiguration<WinRtPhoneDeployConfiguration>("WinRTPhoneDeployConfiguration");
     setDefaultDisplayName(QCoreApplication::translate("WinRt::Internal::WinRtDeployConfiguration",
                                                       "Deploy to Windows Phone"));
-    setSupportedTargetDeviceTypes({Constants::WINRT_DEVICE_TYPE_PHONE});
+    addSupportedTargetDeviceType(Constants::WINRT_DEVICE_TYPE_PHONE);
 }
 
 struct WinRtEmulatorDeployConfiguration : DeployConfiguration
 {
-    WinRtEmulatorDeployConfiguration(Target *target) : DeployConfiguration(target, emulatorDeployConfigurationC) {}
+    WinRtEmulatorDeployConfiguration(Target *target, Core::Id id) : DeployConfiguration(target, id) {}
     void initialize() { stepList()->appendStep(new WinRtPackageDeploymentStep(stepList())); }
 };
 
 WinRtEmulatorDeployConfigurationFactory::WinRtEmulatorDeployConfigurationFactory()
 {
-    registerDeployConfiguration<WinRtEmulatorDeployConfiguration>(emulatorDeployConfigurationC);
+    registerDeployConfiguration<WinRtEmulatorDeployConfiguration>("WinRTEmulatorDeployConfiguration");
     setDefaultDisplayName(QCoreApplication::translate("WinRt::Internal::WinRtDeployConfiguration",
                                                       "Deploy to Windows Phone Emulator"));
-    setSupportedTargetDeviceTypes({Constants::WINRT_DEVICE_TYPE_EMULATOR});
+    addSupportedTargetDeviceType(Constants::WINRT_DEVICE_TYPE_EMULATOR);
 }
 
 WinRtDeployStepFactory::WinRtDeployStepFactory()