QmlDesigner: Add qml connection tracing

Change-Id: I36e51857e29f609e1ff218ea8affa766f61ef42f
Reviewed-by: Thomas Hartmann <thomas.hartmann@qt.io>

src/plugins/qmldesigner/qmltools/qmlconnections.cpp

@@ -9,41 +9,46 @@
 
 namespace QmlDesigner {
 
-QmlConnections::QmlConnections()
+static auto category = ModelTracing::category;
+
+bool QmlConnections::isValid(SL sl) const
 {
+    return isValidQmlConnections(modelNode(), sl);
 }
 
-QmlConnections::QmlConnections(const ModelNode &modelNode)
+bool QmlConnections::isValidQmlConnections(const ModelNode &modelNode, SL sl)
-    : QmlModelNodeFacade(modelNode)
 {
-}
+    using NanotraceHR::keyValue;
-
+    NanotraceHR::Tracer tracer{"qml connection is valid qml connections",
-bool QmlConnections::isValid() const
+                               category(),
-{
+                               keyValue("model node", modelNode),
-    return isValidQmlConnections(modelNode());
+                               keyValue("caller location", sl)};
-}
+    return isValidQmlModelNodeFacade(modelNode) && modelNode.metaInfo().isValid()
-
+           && (modelNode.type() == "Connections" || modelNode.type() == "QtQuick.Connections"
-bool QmlConnections::isValidQmlConnections(const ModelNode &modelNode)
+               || modelNode.type() == "Qt.Connections" || modelNode.type() == "QtQml.Connections");
-{
-    return isValidQmlModelNodeFacade(modelNode)
-            && modelNode.metaInfo().isValid()
-            && (modelNode.type() == "Connections"
-                || modelNode.type() == "QtQuick.Connections"
-                || modelNode.type() == "Qt.Connections"
-                || modelNode.type() == "QtQml.Connections");
 }
 
 /*!
     Removes connections node.
 */
-void QmlConnections::destroy()
+void QmlConnections::destroy(SL sl)
 {
-    Q_ASSERT(isValid());
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml connection destroy",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("caller location", sl)};
     modelNode().destroy();
 }
 
-QString QmlConnections::target() const
+QString QmlConnections::target(SL sl) const
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml connections target",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("caller location", sl)};
+
     if (modelNode().isValid()) {
         const BindingProperty bindingproperty = modelNode().bindingProperty("target");
         if (bindingproperty.isValid())
@@ -53,13 +58,26 @@ QString QmlConnections::target() const
     return QString();
 }
 
-void QmlConnections::setTarget(const QString &target)
+void QmlConnections::setTarget(const QString &target, SL sl)
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml connections set target",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("target", target),
+                               keyValue("caller location", sl)};
+
     modelNode().bindingProperty("target").setExpression(target);
 }
 
-ModelNode QmlConnections::getTargetNode() const
+ModelNode QmlConnections::getTargetNode(SL sl) const
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml connections get target node",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("caller location", sl)};
+
     ModelNode result;
 
     if (!modelNode().isValid())
@@ -91,13 +109,25 @@ ModelNode QmlConnections::getTargetNode() const
     return result;
 }
 
-QList<SignalHandlerProperty> QmlConnections::signalProperties() const
+QList<SignalHandlerProperty> QmlConnections::signalProperties(SL sl) const
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml connections signal properties",
+                               category(),
+                               keyValue("model node", *this),
+                               keyValue("caller location", sl)};
+
     return modelNode().signalProperties();
 }
 
-ModelNode QmlConnections::createQmlConnections(AbstractView *view)
+ModelNode QmlConnections::createQmlConnections(AbstractView *view, SL sl)
 {
+    using NanotraceHR::keyValue;
+    NanotraceHR::Tracer tracer{"qml connections create qml connections",
+                               category(),
+                               keyValue("view", view),
+                               keyValue("caller location", sl)};
+
 #ifdef QDS_USE_PROJECTSTORAGE
     return view->createModelNode("Connections");
 #else

src/plugins/qmldesigner/qmltools/qmlconnections.h

@@ -16,22 +16,26 @@ class QMLDESIGNER_EXPORT QmlConnections : public QmlModelNodeFacade
     friend StatesEditorView;
 
 public:
-    QmlConnections();
+    QmlConnections() = default;
-    QmlConnections(const ModelNode &modelNode);
+
+    QmlConnections(const ModelNode &modelNode)
+        : QmlModelNodeFacade(modelNode)
+    {}
 
     explicit operator bool() const { return isValid(); }
-    bool isValid() const;
-    static bool isValidQmlConnections(const ModelNode &modelNode);
-    void destroy();
 
-    QString target() const;
+    bool isValid(SL sl = {}) const;
-    void setTarget(const QString &target);
+    static bool isValidQmlConnections(const ModelNode &modelNode, SL sl = {});
+    void destroy(SL sl = {});
 
-    ModelNode getTargetNode() const;
+    QString target(SL sl = {}) const;
+    void setTarget(const QString &target, SL sl = {});
 
-    QList<SignalHandlerProperty> signalProperties() const;
+    ModelNode getTargetNode(SL sl = {}) const;
 
-    static ModelNode createQmlConnections(AbstractView *view);
+    QList<SignalHandlerProperty> signalProperties(SL sl = {}) const;
+
+    static ModelNode createQmlConnections(AbstractView *view, SL sl = {});
 };
 
 } //QmlDesigner