Reduce the public API exposed in qscxmlinvokableservice.h

We inline QScxmlInvokableService::finalize into the only place where it
is used.

Furthermore we construct static SCXML state machines through their
metaobjects rather than directly calling the constructor. This way we
can drop the template, make all the service factories QObjects, drop
the intermediate QScxmlScxmlServiceFactory class, and greatly reduce
the API exposed in qscxmlinvokableservice.h.

In addition, as some of the structs in QScxmlExecutableContent are
fairly large, we return them as const references, rather than by value.

Change-Id: Ia9ee61b5668b8af44307787339c08f3c6f23f713
Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>

5 files changed, 170 insertions, 156 deletions

diff --git a/src/scxml/qscxmlcompiler.cpp b/src/scxml/qscxmlcompiler.cpp
index 691f87a..b8434c6 100644
--- a/src/scxml/qscxmlcompiler.cpp
+++ b/src/scxml/qscxmlcompiler.cpp
@@ -473,13 +473,14 @@ private:
 };
 
 #ifndef BUILD_QSCXMLC
-class InvokeDynamicScxmlFactory: public QScxmlScxmlServiceFactory
+class InvokeDynamicScxmlFactory: public QScxmlInvokableServiceFactory
 {
+    Q_OBJECT
 public:
     InvokeDynamicScxmlFactory(const QScxmlExecutableContent::InvokeInfo &invokeInfo,
                               const QVector<QScxmlExecutableContent::StringId> &namelist,
                               const QVector<QScxmlExecutableContent::ParameterInfo> &params)
-        : QScxmlScxmlServiceFactory(invokeInfo, namelist, params)
+        : QScxmlInvokableServiceFactory(invokeInfo, namelist, params)
     {}
 
     void setContent(const QSharedPointer<DocumentModel::ScxmlDocument> &content)
@@ -647,12 +648,12 @@ inline QScxmlInvokableService *InvokeDynamicScxmlFactory::invoke(
         QScxmlStateMachine *parentStateMachine)
 {
     bool ok = true;
-    auto srcexpr = d->calculateSrcexpr(parentStateMachine, &ok);
+    auto srcexpr = calculateSrcexpr(parentStateMachine, invokeInfo().expr, &ok);
     if (!ok)
         return Q_NULLPTR;
 
     if (!srcexpr.isEmpty())
-        return invokeDynamic(parentStateMachine, srcexpr);
+        return invokeDynamicScxmlService(srcexpr, parentStateMachine, this);
 
     auto childStateMachine = DynamicStateMachine::build(m_content.data());
 
@@ -660,15 +661,16 @@ inline QScxmlInvokableService *InvokeDynamicScxmlFactory::invoke(
     dm->setParent(childStateMachine);
     childStateMachine->setDataModel(dm);
 
-    return invokeStatic(childStateMachine, parentStateMachine);
+    return invokeStaticScxmlService(childStateMachine, parentStateMachine, this);
 }
 #endif // BUILD_QSCXMLC
 
 } // anonymous namespace
 
 #ifndef BUILD_QSCXMLC
-QScxmlScxmlService *QScxmlScxmlServiceFactory::invokeDynamic(
-        QScxmlStateMachine *parentStateMachine, const QString &sourceUrl)
+QScxmlScxmlService *invokeDynamicScxmlService(const QString &sourceUrl,
+                                              QScxmlStateMachine *parentStateMachine,
+                                              QScxmlInvokableServiceFactory *factory)
 {
     QScxmlCompiler::Loader *loader = parentStateMachine->loader();
 
@@ -708,7 +710,7 @@ QScxmlScxmlService *QScxmlScxmlServiceFactory::invokeDynamic(
     dm->setParent(childStateMachine);
     childStateMachine->setDataModel(dm);
 
-    return invokeStatic(childStateMachine, parentStateMachine);
+    return invokeStaticScxmlService(childStateMachine, parentStateMachine, factory);
 }
 #endif // BUILD_QSCXMLC
 
@@ -2483,3 +2485,7 @@ QScxmlCompilerPrivate::ParserState::ParserState(QScxmlCompilerPrivate::ParserSta
 {}
 
 QT_END_NAMESPACE
+
+#ifndef BUILD_QSCXMLC
+#include "qscxmlcompiler.moc"
+#endif
diff --git a/src/scxml/qscxmlinvokableservice.cpp b/src/scxml/qscxmlinvokableservice.cpp
index b135e05..9dfda21 100644
--- a/src/scxml/qscxmlinvokableservice.cpp
+++ b/src/scxml/qscxmlinvokableservice.cpp
@@ -59,9 +59,18 @@ QScxmlInvokableServiceFactoryPrivate::QScxmlInvokableServiceFactoryPrivate(
     , parameters(parameters)
 {}
 
+QScxmlStaticScxmlServiceFactoryPrivate::QScxmlStaticScxmlServiceFactoryPrivate(
+        const QMetaObject *metaObject,
+        const QScxmlExecutableContent::InvokeInfo &invokeInfo,
+        const QVector<QScxmlExecutableContent::StringId> &names,
+        const QVector<QScxmlExecutableContent::ParameterInfo> &parameters)
+    : QScxmlInvokableServiceFactoryPrivate(invokeInfo, names, parameters), metaObject(metaObject)
+{
+}
+
 QScxmlInvokableService::QScxmlInvokableService(QScxmlStateMachine *parentStateMachine,
-                                               QObject *parent) :
-    QObject(*(new QScxmlInvokableServicePrivate(parentStateMachine)), parent)
+                                               QScxmlInvokableServiceFactory *factory) :
+    QObject(*(new QScxmlInvokableServicePrivate(parentStateMachine)), factory)
 {
 }
 
@@ -71,58 +80,43 @@ QScxmlStateMachine *QScxmlInvokableService::parentStateMachine() const
     return d->parentStateMachine;
 }
 
-void QScxmlInvokableService::finalize(QScxmlExecutableContent::ContainerId finalize)
-{
-    if (finalize != QScxmlExecutableContent::NoInstruction) {
-        auto psm = parentStateMachine();
-        qCDebug(qscxmlLog) << psm << "running finalize on event";
-        auto smp = QScxmlStateMachinePrivate::get(psm);
-        smp->m_executionEngine->execute(finalize);
-    }
-}
-
-QScxmlInvokableService::QScxmlInvokableService(QScxmlInvokableServicePrivate &dd, QObject *parent) :
-    QObject(dd, parent)
-{
-}
-
 QScxmlInvokableServiceFactory::QScxmlInvokableServiceFactory(
         const QScxmlExecutableContent::InvokeInfo &invokeInfo,
         const QVector<QScxmlExecutableContent::StringId> &names,
-        const QVector<QScxmlExecutableContent::ParameterInfo> &parameters)
-    : d(new QScxmlInvokableServiceFactoryPrivate(invokeInfo, names, parameters))
+        const QVector<QScxmlExecutableContent::ParameterInfo> &parameters,
+        QObject *parent)
+    : QObject(*(new QScxmlInvokableServiceFactoryPrivate(invokeInfo, names, parameters)), parent)
 {}
 
-QScxmlInvokableServiceFactory::~QScxmlInvokableServiceFactory()
-{
-    delete d;
-}
-
-QScxmlExecutableContent::InvokeInfo QScxmlInvokableServiceFactory::invokeInfo() const
+const QScxmlExecutableContent::InvokeInfo &QScxmlInvokableServiceFactory::invokeInfo() const
 {
+    Q_D(const QScxmlInvokableServiceFactory);
     return d->invokeInfo;
 }
 
-QVector<QScxmlExecutableContent::ParameterInfo> QScxmlInvokableServiceFactory::parameters() const
+const QVector<QScxmlExecutableContent::ParameterInfo> &
+QScxmlInvokableServiceFactory::parameters() const
 {
+    Q_D(const QScxmlInvokableServiceFactory);
     return d->parameters;
 }
 
-QVector<QScxmlExecutableContent::StringId> QScxmlInvokableServiceFactory::names() const
+const QVector<QScxmlExecutableContent::StringId> &QScxmlInvokableServiceFactory::names() const
 {
+    Q_D(const QScxmlInvokableServiceFactory);
     return d->names;
 }
 
-QString QScxmlInvokableServiceFactoryPrivate::calculateSrcexpr(QScxmlStateMachine *parent,
-                                                               bool *ok) const
+QString calculateSrcexpr(QScxmlStateMachine *parent, QScxmlExecutableContent::EvaluatorId srcexpr,
+                         bool *ok)
 {
     Q_ASSERT(ok);
     *ok = true;
     auto dataModel = parent->dataModel();
 
-    if (invokeInfo.expr != QScxmlExecutableContent::NoEvaluator) {
+    if (srcexpr != QScxmlExecutableContent::NoEvaluator) {
         *ok = false;
-        auto v = dataModel->evaluateToString(invokeInfo.expr, ok);
+        auto v = dataModel->evaluateToString(srcexpr, ok);
         if (!*ok)
             return QString();
         return v;
@@ -217,29 +211,27 @@ QVariantMap QScxmlInvokableServicePrivate::calculateData(
     return result;
 }
 
-QScxmlScxmlServicePrivate::QScxmlScxmlServicePrivate(QScxmlStateMachine *stateMachine,
-                                                     QScxmlStateMachine *parentStateMachine) :
-    QScxmlInvokableServicePrivate(parentStateMachine), stateMachine(stateMachine)
-{}
-
-QScxmlScxmlServicePrivate::~QScxmlScxmlServicePrivate()
+QScxmlScxmlService::~QScxmlScxmlService()
 {
     delete stateMachine;
 }
 
 QScxmlScxmlService::QScxmlScxmlService(QScxmlStateMachine *stateMachine,
                                        QScxmlStateMachine *parentStateMachine,
-                                       QObject *parent)
-    : QScxmlInvokableService(*(new QScxmlScxmlServicePrivate(stateMachine, parentStateMachine)),
-                             parent)
+                                       QScxmlInvokableServiceFactory *factory)
+    : QScxmlInvokableService(parentStateMachine, factory), stateMachine(stateMachine)
 {
     QScxmlStateMachinePrivate::get(stateMachine)->m_parentStateMachine = parentStateMachine;
 }
 
-bool QScxmlScxmlService::start(const QScxmlInvokableServiceFactory *factory)
+bool QScxmlScxmlService::start()
 {
-    Q_D(QScxmlScxmlService);
-    qCDebug(qscxmlLog) << parentStateMachine() << "preparing to start" << d->stateMachine;
+    Q_D(QScxmlInvokableService);
+    qCDebug(qscxmlLog) << parentStateMachine() << "preparing to start" << stateMachine;
+
+    const QScxmlInvokableServiceFactory *factory
+            = qobject_cast<QScxmlInvokableServiceFactory *>(parent());
+    Q_ASSERT(factory);
 
     bool ok = false;
     auto id = d->calculateId(parentStateMachine(), factory->invokeInfo(), &ok);
@@ -250,72 +242,83 @@ bool QScxmlScxmlService::start(const QScxmlInvokableServiceFactory *factory)
     if (!ok)
         return false;
 
-    QScxmlStateMachinePrivate::get(d->stateMachine)->m_sessionId = id;
-    d->stateMachine->setInitialValues(data);
-    if (d->stateMachine->init()) {
-        qCDebug(qscxmlLog) << parentStateMachine() << "starting" << d->stateMachine;
-        d->stateMachine->start();
+    QScxmlStateMachinePrivate::get(stateMachine)->m_sessionId = id;
+    stateMachine->setInitialValues(data);
+    if (stateMachine->init()) {
+        qCDebug(qscxmlLog) << parentStateMachine() << "starting" << stateMachine;
+        stateMachine->start();
         return true;
     }
 
-    qCDebug(qscxmlLog) << parentStateMachine() << "failed to start" << d->stateMachine;
+    qCDebug(qscxmlLog) << parentStateMachine() << "failed to start" << stateMachine;
     return false;
 }
 
 QString QScxmlScxmlService::id() const
 {
-    Q_D(const QScxmlScxmlService);
-    return d->stateMachine->sessionId();
+    return stateMachine->sessionId();
 }
 
 QString QScxmlScxmlService::name() const
 {
-    Q_D(const QScxmlScxmlService);
-    return d->stateMachine->name();
+    return stateMachine->name();
 }
 
 void QScxmlScxmlService::postEvent(QScxmlEvent *event)
 {
-    Q_D(QScxmlScxmlService);
-    QScxmlStateMachinePrivate::get(d->stateMachine)->postEvent(event);
-}
-
-QScxmlStateMachine *QScxmlScxmlService::stateMachine() const
-{
-    Q_D(const QScxmlScxmlService);
-    return d->stateMachine;
-}
-
-QScxmlScxmlServiceFactory::QScxmlScxmlServiceFactory(
-        const QScxmlExecutableContent::InvokeInfo &invokeInfo,
-        const QVector<QScxmlExecutableContent::StringId> &names,
-        const QVector<QScxmlExecutableContent::ParameterInfo> &parameters)
-    : QScxmlInvokableServiceFactory(invokeInfo, names, parameters)
-{}
-
-QScxmlScxmlService *QScxmlScxmlServiceFactory::invokeStatic(QScxmlStateMachine *childStateMachine,
-                                                            QScxmlStateMachine *parentStateMachine)
-{
-    QScxmlStateMachinePrivate::get(childStateMachine)->setIsInvoked(true);
-    return new QScxmlScxmlService(childStateMachine, parentStateMachine);
+    QScxmlStateMachinePrivate::get(stateMachine)->postEvent(event);
 }
 
 QScxmlDynamicScxmlServiceFactory::QScxmlDynamicScxmlServiceFactory(
         const QScxmlExecutableContent::InvokeInfo &invokeInfo,
         const QVector<QScxmlExecutableContent::StringId> &names,
-        const QVector<QScxmlExecutableContent::ParameterInfo> &parameters)
-    : QScxmlScxmlServiceFactory(invokeInfo, names, parameters)
+        const QVector<QScxmlExecutableContent::ParameterInfo> &parameters,
+        QObject *parent)
+    : QScxmlInvokableServiceFactory(invokeInfo, names, parameters, parent)
 {}
 
 QScxmlInvokableService *QScxmlDynamicScxmlServiceFactory::invoke(
         QScxmlStateMachine *parentStateMachine)
 {
     bool ok = true;
-    auto srcexpr = d->calculateSrcexpr(parentStateMachine, &ok);
+    auto srcexpr = calculateSrcexpr(parentStateMachine, invokeInfo().expr, &ok);
     if (!ok)
         return Q_NULLPTR;
 
-    return invokeDynamic(parentStateMachine, srcexpr);
+    return invokeDynamicScxmlService(srcexpr, parentStateMachine, this);
+}
+
+QScxmlStaticScxmlServiceFactory::QScxmlStaticScxmlServiceFactory(
+        const QMetaObject *metaObject,
+        const QScxmlExecutableContent::InvokeInfo &invokeInfo,
+        const QVector<QScxmlExecutableContent::StringId> &nameList,
+        const QVector<QScxmlExecutableContent::ParameterInfo> &parameters,
+        QObject *parent)
+    : QScxmlInvokableServiceFactory(*(new QScxmlStaticScxmlServiceFactoryPrivate(
+                                      metaObject, invokeInfo, nameList, parameters)), parent)
+{
+}
+
+QScxmlInvokableService *QScxmlStaticScxmlServiceFactory::invoke(
+        QScxmlStateMachine *parentStateMachine)
+{
+    Q_D(const QScxmlStaticScxmlServiceFactory);
+    QScxmlStateMachine *instance = qobject_cast<QScxmlStateMachine *>(
+                d->metaObject->newInstance(Q_ARG(QObject *, this)));
+    return instance ? invokeStaticScxmlService(instance, parentStateMachine, this) : nullptr;
+}
+
+QScxmlInvokableServiceFactory::QScxmlInvokableServiceFactory(
+        QScxmlInvokableServiceFactoryPrivate &dd, QObject *parent)
+    : QObject(dd, parent)
+{}
+
+QScxmlScxmlService *invokeStaticScxmlService(QScxmlStateMachine *childStateMachine,
+                                             QScxmlStateMachine *parentStateMachine,
+                                             QScxmlInvokableServiceFactory *factory)
+{
+    QScxmlStateMachinePrivate::get(childStateMachine)->setIsInvoked(true);
+    return new QScxmlScxmlService(childStateMachine, parentStateMachine, factory);
 }
 
 QT_END_NAMESPACE
diff --git a/src/scxml/qscxmlinvokableservice.h b/src/scxml/qscxmlinvokableservice.h
index 9e317cc..63b9ec3 100644
--- a/src/scxml/qscxmlinvokableservice.h
+++ b/src/scxml/qscxmlinvokableservice.h
@@ -60,97 +60,66 @@ class Q_SCXML_EXPORT QScxmlInvokableService : public QObject
 
 public:
     QScxmlInvokableService(QScxmlStateMachine *parentStateMachine,
-                           QObject *parent = nullptr);
+                           QScxmlInvokableServiceFactory *parent);
 
     QScxmlStateMachine *parentStateMachine() const;
 
-    virtual bool start(const QScxmlInvokableServiceFactory *factory) = 0;
+    virtual bool start() = 0;
     virtual QString id() const = 0;
     virtual QString name() const = 0;
     virtual void postEvent(QScxmlEvent *event) = 0;
-
-    void finalize(QScxmlExecutableContent::ContainerId finalize);
-
-protected:
-    QScxmlInvokableService(QScxmlInvokableServicePrivate &dd, QObject *parent = nullptr);
 };
 
 class QScxmlInvokableServiceFactoryPrivate;
-class Q_SCXML_EXPORT QScxmlInvokableServiceFactory
+class Q_SCXML_EXPORT QScxmlInvokableServiceFactory : public QObject
 {
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QScxmlInvokableServiceFactory)
+    Q_PROPERTY(QScxmlExecutableContent::InvokeInfo invokeInfo READ invokeInfo CONSTANT)
+    Q_PROPERTY(QVector<QScxmlExecutableContent::ParameterInfo> parameters READ parameters CONSTANT)
+    Q_PROPERTY(QVector<QScxmlExecutableContent::StringId> names READ names CONSTANT)
+
 public:
     QScxmlInvokableServiceFactory(
             const QScxmlExecutableContent::InvokeInfo &invokeInfo,
             const QVector<QScxmlExecutableContent::StringId> &names,
-            const QVector<QScxmlExecutableContent::ParameterInfo> &parameters);
-    virtual ~QScxmlInvokableServiceFactory();
+            const QVector<QScxmlExecutableContent::ParameterInfo> &parameters,
+            QObject *parent = nullptr);
 
     virtual QScxmlInvokableService *invoke(QScxmlStateMachine *parentStateMachine) = 0;
-    QScxmlExecutableContent::InvokeInfo invokeInfo() const;
-    QVector<QScxmlExecutableContent::ParameterInfo> parameters() const;
-    QVector<QScxmlExecutableContent::StringId> names() const;
+    const QScxmlExecutableContent::InvokeInfo &invokeInfo() const;
+    const QVector<QScxmlExecutableContent::ParameterInfo> &parameters() const;
+    const QVector<QScxmlExecutableContent::StringId> &names() const;
 
 protected:
-    QScxmlInvokableServiceFactoryPrivate *d;
+    QScxmlInvokableServiceFactory(QScxmlInvokableServiceFactoryPrivate &dd, QObject *parent);
 };
 
-class QScxmlScxmlServicePrivate;
-class Q_SCXML_EXPORT QScxmlScxmlService: public QScxmlInvokableService
+class QScxmlStaticScxmlServiceFactoryPrivate;
+class Q_SCXML_EXPORT QScxmlStaticScxmlServiceFactory: public QScxmlInvokableServiceFactory
 {
     Q_OBJECT
-    Q_DECLARE_PRIVATE(QScxmlScxmlService)
-    Q_PROPERTY(QScxmlStateMachine *stateMachine READ stateMachine CONSTANT)
-public:
-    QScxmlScxmlService(QScxmlStateMachine *stateMachine,
-                       QScxmlStateMachine *parentStateMachine,
-                       QObject *parent = nullptr);
-
-    bool start(const QScxmlInvokableServiceFactory *factory) Q_DECL_OVERRIDE;
-    QString id() const Q_DECL_OVERRIDE;
-    QString name() const Q_DECL_OVERRIDE;
-    void postEvent(QScxmlEvent *event) Q_DECL_OVERRIDE;
-
-    QScxmlStateMachine *stateMachine() const;
-};
-
-class Q_SCXML_EXPORT QScxmlScxmlServiceFactory: public QScxmlInvokableServiceFactory
-{
-public:
-    QScxmlScxmlServiceFactory(const QScxmlExecutableContent::InvokeInfo &invokeInfo,
-                              const QVector<QScxmlExecutableContent::StringId> &names,
-                              const QVector<QScxmlExecutableContent::ParameterInfo> &parameters);
-
-protected:
-    QScxmlScxmlService *invokeDynamic(QScxmlStateMachine *parentStateMachine,
-                                      const QString &sourceUrl);
-    QScxmlScxmlService *invokeStatic(QScxmlStateMachine *childStateMachine,
-                                     QScxmlStateMachine *parentStateMachine);
-};
-
-template<class T>
-class QScxmlStaticScxmlServiceFactory: public QScxmlScxmlServiceFactory
-{
+    Q_DECLARE_PRIVATE(QScxmlStaticScxmlServiceFactory)
 public:
     QScxmlStaticScxmlServiceFactory(
-            const QScxmlExecutableContent::InvokeInfo &newInvokeInfo,
-            const QVector<QScxmlExecutableContent::StringId> &newNameList,
-            const QVector<QScxmlExecutableContent::ParameterInfo> &newParameters)
-        : QScxmlScxmlServiceFactory(newInvokeInfo, newNameList, newParameters)
-    {}
-
-    QScxmlInvokableService *invoke(QScxmlStateMachine *parentStateMachine) Q_DECL_OVERRIDE
-    {
-        return invokeStatic(new T, parentStateMachine);
-    }
+            const QMetaObject *metaObject,
+            const QScxmlExecutableContent::InvokeInfo &invokeInfo,
+            const QVector<QScxmlExecutableContent::StringId> &nameList,
+            const QVector<QScxmlExecutableContent::ParameterInfo> &parameters,
+            QObject *parent = nullptr);
+
+    QScxmlInvokableService *invoke(QScxmlStateMachine *parentStateMachine) Q_DECL_OVERRIDE;
 };
 
-class Q_SCXML_EXPORT QScxmlDynamicScxmlServiceFactory: public QScxmlScxmlServiceFactory
+class Q_SCXML_EXPORT QScxmlDynamicScxmlServiceFactory: public QScxmlInvokableServiceFactory
 {
+    Q_OBJECT
 public:
     QScxmlDynamicScxmlServiceFactory(
             const QScxmlExecutableContent::InvokeInfo &invokeInfo,
             const QVector<QScxmlExecutableContent::StringId> &names,
-            const QVector<QScxmlExecutableContent::ParameterInfo> &parameters);
+            const QVector<QScxmlExecutableContent::ParameterInfo> &parameters,
+            QObject *parent = nullptr);
 
     QScxmlInvokableService *invoke(QScxmlStateMachine *parentStateMachine) Q_DECL_OVERRIDE;
 };
diff --git a/src/scxml/qscxmlinvokableservice_p.h b/src/scxml/qscxmlinvokableservice_p.h
index 52bd6d0..e2a9e7b 100644
--- a/src/scxml/qscxmlinvokableservice_p.h
+++ b/src/scxml/qscxmlinvokableservice_p.h
@@ -71,7 +71,7 @@ public:
     QScxmlStateMachine *parentStateMachine;
 };
 
-class QScxmlInvokableServiceFactoryPrivate
+class QScxmlInvokableServiceFactoryPrivate : public QObjectPrivate
 {
 public:
     QScxmlInvokableServiceFactoryPrivate(
@@ -79,23 +79,50 @@ public:
             const QVector<QScxmlExecutableContent::StringId> &names,
             const QVector<QScxmlExecutableContent::ParameterInfo> &parameters);
 
-    QString calculateSrcexpr(QScxmlStateMachine *parent, bool *ok) const;
-
     QScxmlExecutableContent::InvokeInfo invokeInfo;
     QVector<QScxmlExecutableContent::StringId> names;
     QVector<QScxmlExecutableContent::ParameterInfo> parameters;
 };
 
-class QScxmlScxmlServicePrivate : public QScxmlInvokableServicePrivate
+class Q_SCXML_EXPORT QScxmlScxmlService: public QScxmlInvokableService
 {
+    Q_OBJECT
+    Q_DECLARE_PRIVATE(QScxmlInvokableService)
 public:
-    QScxmlScxmlServicePrivate(QScxmlStateMachine *stateMachine,
-                              QScxmlStateMachine *parentStateMachine);
-    ~QScxmlScxmlServicePrivate();
+    QScxmlScxmlService(QScxmlStateMachine *stateMachine,
+                       QScxmlStateMachine *parentStateMachine,
+                       QScxmlInvokableServiceFactory *parent);
+    ~QScxmlScxmlService();
+
+    bool start() Q_DECL_OVERRIDE;
+    QString id() const Q_DECL_OVERRIDE;
+    QString name() const Q_DECL_OVERRIDE;
+    void postEvent(QScxmlEvent *event) Q_DECL_OVERRIDE;
 
     QScxmlStateMachine *stateMachine;
 };
 
+class QScxmlStaticScxmlServiceFactoryPrivate : public QScxmlInvokableServiceFactoryPrivate
+{
+public:
+    QScxmlStaticScxmlServiceFactoryPrivate(
+            const QMetaObject *metaObject,
+            const QScxmlExecutableContent::InvokeInfo &invokeInfo,
+            const QVector<QScxmlExecutableContent::StringId> &names,
+            const QVector<QScxmlExecutableContent::ParameterInfo> &parameters);
+
+    const QMetaObject *metaObject;
+};
+
+QScxmlScxmlService *invokeDynamicScxmlService(const QString &sourceUrl,
+                                              QScxmlStateMachine *parentStateMachine,
+                                              QScxmlInvokableServiceFactory *factory);
+QScxmlScxmlService *invokeStaticScxmlService(QScxmlStateMachine *childStateMachine,
+                                             QScxmlStateMachine *parentStateMachine,
+                                             QScxmlInvokableServiceFactory *factory);
+QString calculateSrcexpr(QScxmlStateMachine *parent, QScxmlExecutableContent::EvaluatorId srcexpr,
+                         bool *ok);
+
 QT_END_NAMESPACE
 
 #endif // QSCXMLINVOKABLESERVICE_P_H
diff --git a/src/scxml/qscxmlstatemachine.cpp b/src/scxml/qscxmlstatemachine.cpp
index cfa37de..1397b71 100644
--- a/src/scxml/qscxmlstatemachine.cpp
+++ b/src/scxml/qscxmlstatemachine.cpp
@@ -449,7 +449,7 @@ void QScxmlStateMachinePrivate::addService(int invokingState)
             continue; // service failed to start
         const QString serviceName = service->name();
         m_invokedServices[size_t(id)] = { invokingState, service, serviceName };
-        service->start(factory);
+        service->start();
     }
     emitInvokedServicesChanged();
 }
@@ -533,7 +533,16 @@ void QScxmlStateMachinePrivate::postEvent(QScxmlEvent *event)
             auto factory = serviceFactory(id);
             if (event->invokeId() == service->id()) {
                 setEvent(event);
-                service->finalize(factory->invokeInfo().finalize);
+
+                const QScxmlExecutableContent::ContainerId finalize
+                        = factory->invokeInfo().finalize;
+                if (finalize != QScxmlExecutableContent::NoContainer) {
+                    auto psm = service->parentStateMachine();
+                    qCDebug(qscxmlLog) << psm << "running finalize on event";
+                    auto smp = QScxmlStateMachinePrivate::get(psm);
+                    smp->m_executionEngine->execute(finalize);
+                }
+
                 resetEvent();
             }
             if (factory->invokeInfo().autoforward) {