Revert "analyzer: move convenience factory back to base plugin"

This reverts commit 06a41da04e.

Change-Id: I06a41da04e726ffd35da18d99cd2f46cb99467bf
Reviewed-on: http://codereview.qt.nokia.com/1094
Reviewed-by: Qt Sanity Bot <qt_sanity_bot@ovi.com>
Reviewed-by: hjk <qthjk@ovi.com>

src/plugins/analyzerbase/analyzermanager.cpp

@@ -42,8 +42,6 @@
 #include "analyzerutils.h"
 #include "ianalyzertool.h"
 
-#include "startremotedialog.h"
-
 #include <coreplugin/coreconstants.h>
 #include <coreplugin/findplaceholder.h>
 #include <coreplugin/icore.h>
@@ -848,6 +846,11 @@ void AnalyzerManager::stopTool()
     stopAction()->trigger();
 }
 
+void AnalyzerManager::startLocalTool(IAnalyzerTool *tool, StartMode mode)
+{
+    m_instance->d->startLocalTool(tool, mode);
+}
+
 QAction *AnalyzerManager::stopAction()
 {
     return m_instance->d->m_stopAction;
@@ -867,36 +870,6 @@ IAnalyzerTool *AnalyzerManager::toolFromId(const QByteArray &id)
     return 0;
 }
 
-static void startRemoteTool(IAnalyzerTool *tool, StartMode mode)
-{
-    StartRemoteDialog dlg;
-    if (dlg.exec() != QDialog::Accepted)
-        return;
-
-    AnalyzerStartParameters sp;
-    sp.toolId = tool->id();
-    sp.startMode = mode;
-    sp.connParams = dlg.sshParams();
-    sp.debuggee = dlg.executable();
-    sp.debuggeeArgs = dlg.arguments();
-    sp.displayName = dlg.executable();
-    sp.workingDirectory = dlg.workingDirectory();
-
-    AnalyzerRunControl *rc = new AnalyzerRunControl(tool, sp, 0);
-    QObject::connect(AnalyzerManager::stopAction(), SIGNAL(triggered()), rc, SLOT(stopIt()));
-
-    ProjectExplorer::ProjectExplorerPlugin::instance()->startRunControl(rc, tool->id());
-}
-
-void AnalyzerManager::defaultStartTool(IAnalyzerTool *tool, StartMode mode)
-{
-    if (mode == StartLocal)
-        m_instance->d->startLocalTool(tool, mode);
-    if (mode == StartRemote)
-        startRemoteTool(tool, mode);
-    //    m_instance->d->startRemoteTool(tool, mode);
-}
-
 } // namespace Analyzer
 
 #include "analyzermanager.moc"

src/plugins/analyzerbase/analyzermanager.h

@@ -84,8 +84,7 @@ public:
     static void stopTool();
 
     // Convenience functions.
-    //static void startLocalTool(IAnalyzerTool *tool, StartMode mode);
-    static void defaultStartTool(IAnalyzerTool *tool, StartMode mode);
+    static void startLocalTool(IAnalyzerTool *tool, StartMode mode);
 
     static QString msgToolStarted(const QString &name);
     static QString msgToolFinished(const QString &name, int issuesFound);

src/plugins/analyzerbase/analyzerplugin.cpp

@@ -33,14 +33,8 @@
 **************************************************************************/
 
 #include "analyzerplugin.h"
-
 #include "analyzerconstants.h"
 #include "analyzermanager.h"
-#include "analyzerruncontrol.h"
-#include "analyzersettings.h"
-#include "analyzerstartparameters.h"
-#include "analyzerrunconfigwidget.h"
-#include "startremotedialog.h"
 #include "ianalyzertool.h"
 
 #include <coreplugin/icore.h>
@@ -49,152 +43,19 @@
 #include <coreplugin/editormanager/editormanager.h>
 
 #include <extensionsystem/pluginmanager.h>
-
-#include <projectexplorer/applicationrunconfiguration.h>
-#include <projectexplorer/projectexplorer.h>
 #include <projectexplorer/task.h>
 #include <projectexplorer/taskhub.h>
 
-#include <remotelinux/linuxdeviceconfiguration.h>
-#include <remotelinux/remotelinuxrunconfiguration.h>
-
-#include <utils/qtcassert.h>
-
 #include <QtCore/QtPlugin>
-#include <QtGui/QAction>
 #include <QtGui/QMessageBox>
 #include <QtGui/QMainWindow>
 #include <QtGui/QApplication>
 
 using namespace Analyzer;
 using namespace Analyzer::Internal;
-using namespace ProjectExplorer;
 
 static AnalyzerPlugin *m_instance = 0;
 
-namespace Analyzer {
-namespace Internal {
-
-/////////////////////////////////////////////////////////////////////////////////
-//
-// AnalyzerRunControlFactory
-//
-/////////////////////////////////////////////////////////////////////////////////
-
-static AnalyzerStartParameters localStartParameters(RunConfiguration *runConfiguration)
-{
-    AnalyzerStartParameters sp;
-    QTC_ASSERT(runConfiguration, return sp);
-    LocalApplicationRunConfiguration *rc =
-            qobject_cast<LocalApplicationRunConfiguration *>(runConfiguration);
-    QTC_ASSERT(rc, return sp);
-
-    sp.startMode = StartLocal;
-    sp.environment = rc->environment();
-    sp.workingDirectory = rc->workingDirectory();
-    sp.debuggee = rc->executable();
-    sp.debuggeeArgs = rc->commandLineArguments();
-    sp.displayName = rc->displayName();
-    sp.connParams.host = QLatin1String("localhost");
-    sp.connParams.port = rc->qmlDebugServerPort();
-    return sp;
-}
-
-static AnalyzerStartParameters remoteLinuxStartParameters(RunConfiguration *runConfiguration)
-{
-    AnalyzerStartParameters sp;
-    RemoteLinux::RemoteLinuxRunConfiguration * const rc
-        = qobject_cast<RemoteLinux::RemoteLinuxRunConfiguration *>(runConfiguration);
-    QTC_ASSERT(rc, return sp);
-
-    sp.startMode = StartRemote;
-    sp.debuggee = rc->remoteExecutableFilePath();
-    sp.debuggeeArgs = rc->arguments();
-    sp.connParams = rc->deviceConfig()->sshParameters();
-    sp.analyzerCmdPrefix = rc->commandPrefix();
-    sp.displayName = rc->displayName();
-    return sp;
-}
-
-
-class AnalyzerRunControlFactory : public ProjectExplorer::IRunControlFactory
-{
-    Q_OBJECT
-
-public:
-    AnalyzerRunControlFactory(QObject *parent = 0);
-
-    typedef ProjectExplorer::RunConfiguration RunConfiguration;
-    typedef ProjectExplorer::RunControl RunControl;
-
-    // IRunControlFactory
-    bool canRun(RunConfiguration *runConfiguration, const QString &mode) const;
-    RunControl *create(RunConfiguration *runConfiguration, const QString &mode);
-    QString displayName() const;
-
-    ProjectExplorer::IRunConfigurationAspect *createRunConfigurationAspect();
-    ProjectExplorer::RunConfigWidget *createConfigurationWidget(RunConfiguration *runConfiguration);
-};
-
-AnalyzerRunControlFactory::AnalyzerRunControlFactory(QObject *parent)
-    : IRunControlFactory(parent)
-{
-    setObjectName(QLatin1String("AnalyzerRunControlFactory"));
-}
-
-bool AnalyzerRunControlFactory::canRun(RunConfiguration *runConfiguration, const QString &mode) const
-{
-    Q_UNUSED(runConfiguration);
-    // FIXME: This is not generic.
-    return mode.startsWith("Callgrind") || mode.startsWith("Memcheck") || mode == "QmlProfiler";
-}
-
-RunControl *AnalyzerRunControlFactory::create(RunConfiguration *runConfiguration, const QString &mode)
-{
-    QTC_ASSERT(canRun(runConfiguration, mode), return 0);
-
-    AnalyzerStartParameters sp;
-    if (qobject_cast<ProjectExplorer::LocalApplicationRunConfiguration *>(runConfiguration)) {
-        sp = localStartParameters(runConfiguration);
-    } else if (qobject_cast<RemoteLinux::RemoteLinuxRunConfiguration *>(runConfiguration)) {
-        sp = remoteLinuxStartParameters(runConfiguration);
-    } else {
-        // Might be S60DeviceRunfiguration, or something else ...
-        //sp.startMode = StartRemote;
-        sp.startMode = StartRemote;
-    }
-
-    IAnalyzerTool *tool = AnalyzerManager::toolFromId(mode.toLatin1());
-    AnalyzerRunControl *rc = new AnalyzerRunControl(tool, sp, runConfiguration);
-    QObject::connect(AnalyzerManager::stopAction(), SIGNAL(triggered()), rc, SLOT(stopIt()));
-    //m_isRunning = true;
-    return rc;
-}
-
-QString AnalyzerRunControlFactory::displayName() const
-{
-    return tr("Analyzer");
-}
-
-IRunConfigurationAspect *AnalyzerRunControlFactory::createRunConfigurationAspect()
-{
-    return new AnalyzerProjectSettings;
-}
-
-RunConfigWidget *AnalyzerRunControlFactory::createConfigurationWidget(RunConfiguration *runConfiguration)
-{
-    LocalApplicationRunConfiguration *localRc =
-        qobject_cast<LocalApplicationRunConfiguration *>(runConfiguration);
-    if (!localRc)
-        return 0;
-    AnalyzerProjectSettings *settings = runConfiguration->extraAspect<AnalyzerProjectSettings>();
-    if (!settings)
-        return 0;
-
-    AnalyzerRunConfigWidget *ret = new AnalyzerRunConfigWidget;
-    ret->setRunConfiguration(runConfiguration);
-    return ret;
-}
 
 ////////////////////////////////////////////////////////////////////////
 //
@@ -245,9 +106,6 @@ bool AnalyzerPlugin::initialize(const QStringList &arguments, QString *errorStri
     //: Category under which Analyzer tasks are listed in build issues view
     hub->addCategory(QLatin1String(Constants::ANALYZERTASK_ID), tr("Analyzer"));
 
-    AnalyzerRunControlFactory *factory = new AnalyzerRunControlFactory();
-    addAutoReleasedObject(factory);
-
     return true;
 }
 
@@ -267,9 +125,4 @@ AnalyzerPlugin *AnalyzerPlugin::instance()
     return m_instance;
 }
 
-} // namespace Internal
-} // namespace Analyzer
-
 Q_EXPORT_PLUGIN(AnalyzerPlugin)
-
-#include "analyzerplugin.moc"

src/plugins/analyzerbase/ianalyzertool.cpp

@@ -64,9 +64,4 @@ QString IAnalyzerTool::defaultActionName(const IAnalyzerTool *tool, StartMode mo
     return base;
 }
 
-void IAnalyzerTool::defaultStartTool(IAnalyzerTool *tool, StartMode mode)
-{
-    AnalyzerManager::defaultStartTool(tool, mode);
-}
-
 } // namespace Analyzer

src/plugins/analyzerbase/ianalyzertool.h

@@ -105,7 +105,6 @@ public:
     static QByteArray defaultMenuGroup(StartMode mode);
     static QByteArray defaultActionId(const IAnalyzerTool *tool, StartMode mode);
     static QString defaultActionName(const IAnalyzerTool *tool, StartMode mode);
-    static void defaultStartTool(IAnalyzerTool *tool, StartMode mode);
 
     /// This gets called after all analyzation tools where initialized.
     virtual void extensionsInitialized() = 0;
@@ -125,7 +124,7 @@ public:
     virtual IAnalyzerEngine *createEngine(const AnalyzerStartParameters &sp,
         ProjectExplorer::RunConfiguration *runConfiguration = 0) = 0;
 
-    virtual void startTool(StartMode mode) { defaultStartTool(this, mode); }
+    virtual void startTool(StartMode mode) = 0;
 
     /// Called when tools gets selected.
     virtual void toolSelected() const {}

src/plugins/qmlprofiler/qmlprofilertool.cpp

@@ -537,3 +537,11 @@ void QmlProfilerTool::updateRecordingState()
     if (d->m_traceWindow->isRecording())
         clearDisplay();
 }
+
+void QmlProfilerTool::startTool(StartMode mode)
+{
+    if (mode == StartLocal)
+        AnalyzerManager::startLocalTool(this, mode);
+    if (mode == StartRemote)
+        AnalyzerManager::startLocalTool(this, mode);
+}

src/plugins/qmlprofiler/qmlprofilertool.h

@@ -62,6 +62,7 @@ public:
         ProjectExplorer::RunConfiguration *runConfiguration = 0);
 
     QWidget *createControlWidget();
+    void startTool(Analyzer::StartMode mode);
 
 public slots:
     void connectClient(int port);

src/plugins/valgrind/callgrindtool.cpp

@@ -680,6 +680,11 @@ IAnalyzerEngine *CallgrindToolPrivate::createEngine(const AnalyzerStartParameter
     return engine;
 }
 
+void CallgrindTool::startTool(StartMode mode)
+{
+    ValgrindPlugin::startValgrindTool(this, mode);
+}
+
 QWidget *CallgrindTool::createControlWidget()
 {
     return d->createControlWidget();

src/plugins/valgrind/callgrindtool.h

@@ -60,6 +60,8 @@ public:
         ProjectExplorer::RunConfiguration *runConfiguration = 0);
     QWidget *createControlWidget();
 
+    void startTool(Analyzer::StartMode mode);
+
 private:
     CallgrindToolPrivate *d;
 };

src/plugins/valgrind/memchecktool.cpp

@@ -467,6 +467,11 @@ IAnalyzerEngine *MemcheckTool::createEngine(const AnalyzerStartParameters &sp,
     return engine;
 }
 
+void MemcheckTool::startTool(StartMode mode)
+{
+    ValgrindPlugin::startValgrindTool(this, mode);
+}
+
 void MemcheckTool::engineStarting(const IAnalyzerEngine *engine)
 {
     clearErrorView();

src/plugins/valgrind/memchecktool.h

@@ -118,6 +118,7 @@ private:
 
     Analyzer::IAnalyzerEngine *createEngine(const Analyzer::AnalyzerStartParameters &sp,
                                ProjectExplorer::RunConfiguration *runConfiguration = 0);
+    void startTool(Analyzer::StartMode mode);
 
     void clearErrorView();
 

src/plugins/valgrind/valgrindplugin.cpp

@@ -42,6 +42,17 @@
 
 #include <analyzerbase/analyzerconstants.h>
 #include <analyzerbase/analyzermanager.h>
+#include <analyzerbase/analyzerrunconfigwidget.h>
+#include <analyzerbase/analyzerruncontrol.h>
+#include <analyzerbase/analyzersettings.h>
+#include <analyzerbase/analyzerstartparameters.h>
+#include <analyzerbase/startremotedialog.h>
+
+#include <projectexplorer/applicationrunconfiguration.h>
+#include <projectexplorer/projectexplorer.h>
+
+#include <remotelinux/linuxdeviceconfiguration.h>
+#include <remotelinux/remotelinuxrunconfiguration.h>
 
 #include <utils/qtcassert.h>
 
@@ -51,16 +62,168 @@
 #include <QtGui/QAction>
 
 using namespace Analyzer;
+using namespace Valgrind::Internal;
+using namespace ProjectExplorer;
+
+/////////////////////////////////////////////////////////////////////////////////
+//
+// ValgrindRunControlFactory
+//
+/////////////////////////////////////////////////////////////////////////////////
 
 namespace Valgrind {
 namespace Internal {
 
+static AnalyzerStartParameters localStartParameters(RunConfiguration *runConfiguration)
+{
+    AnalyzerStartParameters sp;
+    QTC_ASSERT(runConfiguration, return sp);
+    LocalApplicationRunConfiguration *rc =
+            qobject_cast<LocalApplicationRunConfiguration *>(runConfiguration);
+    QTC_ASSERT(rc, return sp);
+
+    sp.startMode = StartLocal;
+    sp.environment = rc->environment();
+    sp.workingDirectory = rc->workingDirectory();
+    sp.debuggee = rc->executable();
+    sp.debuggeeArgs = rc->commandLineArguments();
+    sp.displayName = rc->displayName();
+    sp.connParams.host = QLatin1String("localhost");
+    sp.connParams.port = rc->qmlDebugServerPort();
+    return sp;
+}
+
+static AnalyzerStartParameters remoteLinuxStartParameters(RunConfiguration *runConfiguration)
+{
+    AnalyzerStartParameters sp;
+    RemoteLinux::RemoteLinuxRunConfiguration * const rc
+        = qobject_cast<RemoteLinux::RemoteLinuxRunConfiguration *>(runConfiguration);
+    QTC_ASSERT(rc, return sp);
+
+    sp.startMode = StartRemote;
+    sp.debuggee = rc->remoteExecutableFilePath();
+    sp.debuggeeArgs = rc->arguments();
+    sp.connParams = rc->deviceConfig()->sshParameters();
+    sp.analyzerCmdPrefix = rc->commandPrefix();
+    sp.displayName = rc->displayName();
+    return sp;
+}
+
+
+class ValgrindRunControlFactory: public ProjectExplorer::IRunControlFactory
+{
+    Q_OBJECT
+
+public:
+    ValgrindRunControlFactory(QObject *parent = 0);
+
+    typedef ProjectExplorer::RunConfiguration RunConfiguration;
+    typedef ProjectExplorer::RunControl RunControl;
+
+    // IRunControlFactory
+    bool canRun(RunConfiguration *runConfiguration, const QString &mode) const;
+    RunControl *create(RunConfiguration *runConfiguration, const QString &mode);
+    QString displayName() const;
+
+    ProjectExplorer::IRunConfigurationAspect *createRunConfigurationAspect();
+    ProjectExplorer::RunConfigWidget *createConfigurationWidget(RunConfiguration *runConfiguration);
+};
+
+ValgrindRunControlFactory::ValgrindRunControlFactory(QObject *parent)
+    : IRunControlFactory(parent)
+{
+    setObjectName(QLatin1String("ValgrindRunControlFactory"));
+}
+
+bool ValgrindRunControlFactory::canRun(RunConfiguration *runConfiguration, const QString &mode) const
+{
+    Q_UNUSED(runConfiguration);
+    return mode.startsWith("Callgrind") || mode.startsWith("Memcheck");
+}
+
+RunControl *ValgrindRunControlFactory::create(RunConfiguration *runConfiguration, const QString &mode)
+{
+    QTC_ASSERT(canRun(runConfiguration, mode), return 0);
+
+    AnalyzerStartParameters sp;
+    if (qobject_cast<ProjectExplorer::LocalApplicationRunConfiguration *>(runConfiguration)) {
+        sp = localStartParameters(runConfiguration);
+    } else if (qobject_cast<RemoteLinux::RemoteLinuxRunConfiguration *>(runConfiguration)) {
+        sp = remoteLinuxStartParameters(runConfiguration);
+    } else {
+        // Might be S60DeviceRunfiguration, or something else ...
+        //sp.startMode = StartRemote;
+        sp.startMode = StartRemote;
+    }
+
+    IAnalyzerTool *tool = AnalyzerManager::toolFromId(mode.toLatin1());
+    AnalyzerRunControl *rc = new AnalyzerRunControl(tool, sp, runConfiguration);
+    QObject::connect(AnalyzerManager::stopAction(), SIGNAL(triggered()), rc, SLOT(stopIt()));
+    //m_isRunning = true;
+    return rc;
+}
+
+QString ValgrindRunControlFactory::displayName() const
+{
+    return tr("Analyzer");
+}
+
+IRunConfigurationAspect *ValgrindRunControlFactory::createRunConfigurationAspect()
+{
+    return new AnalyzerProjectSettings;
+}
+
+RunConfigWidget *ValgrindRunControlFactory::createConfigurationWidget(RunConfiguration *runConfiguration)
+{
+    LocalApplicationRunConfiguration *localRc =
+        qobject_cast<LocalApplicationRunConfiguration *>(runConfiguration);
+    if (!localRc)
+        return 0;
+    AnalyzerProjectSettings *settings = runConfiguration->extraAspect<AnalyzerProjectSettings>();
+    if (!settings)
+        return 0;
+
+    AnalyzerRunConfigWidget *ret = new AnalyzerRunConfigWidget;
+    ret->setRunConfiguration(runConfiguration);
+    return ret;
+}
+
 /////////////////////////////////////////////////////////////////////////////////
 //
 // ValgrindPlugin
 //
 /////////////////////////////////////////////////////////////////////////////////
 
+static void startRemoteTool(IAnalyzerTool *tool, StartMode mode)
+{
+    Q_UNUSED(tool);
+    StartRemoteDialog dlg;
+    if (dlg.exec() != QDialog::Accepted)
+        return;
+
+    AnalyzerStartParameters sp;
+    sp.toolId = tool->id();
+    sp.startMode = mode;
+    sp.connParams = dlg.sshParams();
+    sp.debuggee = dlg.executable();
+    sp.debuggeeArgs = dlg.arguments();
+    sp.displayName = dlg.executable();
+    sp.workingDirectory = dlg.workingDirectory();
+
+    AnalyzerRunControl *rc = new AnalyzerRunControl(tool, sp, 0);
+    //m_currentRunControl = rc;
+    QObject::connect(AnalyzerManager::stopAction(), SIGNAL(triggered()), rc, SLOT(stopIt()));
+
+    ProjectExplorer::ProjectExplorerPlugin::instance()->startRunControl(rc, tool->id());
+}
+
+void ValgrindPlugin::startValgrindTool(IAnalyzerTool *tool, StartMode mode)
+{
+    if (mode == StartLocal)
+        AnalyzerManager::startLocalTool(tool, mode);
+    if (mode == StartRemote)
+        startRemoteTool(tool, mode);
+}
 
 static AbstractAnalyzerSubConfig *valgrindConfigFactory()
 {
@@ -102,6 +265,9 @@ bool ValgrindPlugin::initialize(const QStringList &, QString *)
     AnalyzerManager::addTool(new MemcheckTool(this), modes);
     AnalyzerManager::addTool(new CallgrindTool(this), modes);
 
+    ValgrindRunControlFactory *factory = new ValgrindRunControlFactory();
+    addAutoReleasedObject(factory);
+
     return true;
 }
 

src/plugins/valgrind/valgrindplugin.h

@@ -51,6 +51,7 @@ public:
     virtual bool initialize(const QStringList &arguments, QString *errorString);
     virtual void extensionsInitialized() {}
 
+    static void startValgrindTool(Analyzer::IAnalyzerTool *tool, Analyzer::StartMode mode);
 };
 
 } // namespace Internal