diff --git a/src/plugins/qmlprofiler/qmlprofilerbindingloopsrenderpass.cpp b/src/plugins/qmlprofiler/qmlprofilerbindingloopsrenderpass.cpp
index 016dabcbfcefe707c7bf0d7a5371c2aae64b0543..b5ef2651a8442bfc0496597c13d61b3e2e915974 100644
--- a/src/plugins/qmlprofiler/qmlprofilerbindingloopsrenderpass.cpp
+++ b/src/plugins/qmlprofiler/qmlprofilerbindingloopsrenderpass.cpp
@@ -45,6 +45,12 @@ struct BindingLoopsRenderPassState : public Timeline::TimelineRenderPass::State
     BindingLoopMaterial material;
     int indexFrom;
     int indexTo;
+
+    QVector<QSGNode *> m_expandedRows;
+    const QVector<QSGNode *> &expandedRows() const { return m_expandedRows; }
+
+    QSGNode *m_collapsedOverlay;
+    QSGNode *collapsedOverlay() const { return m_collapsedOverlay; }
 };
 
 struct Point2DWithOffset {
@@ -106,13 +112,13 @@ void updateNodes(const QmlProfilerRangeModel *model, int from, int to,
         BindlingLoopsGeometry &row = expandedPerRow[i];
         if (row.usedVertices > 0) {
             row.allocate(&state->material);
-            state->expandedRows[i]->appendChildNode(row.node);
+            state->m_expandedRows[i]->appendChildNode(row.node);
         }
     }
 
     if (collapsed.usedVertices > 0) {
         collapsed.allocate(&state->material);
-        state->collapsedOverlay->appendChildNode(collapsed.node);
+        state->m_collapsedOverlay->appendChildNode(collapsed.node);
     }
 
     int rowHeight = Timeline::TimelineModel::defaultRowHeight();
@@ -150,25 +156,23 @@ Timeline::TimelineRenderPass::State *QmlProfilerBindingLoopsRenderPass::update(
     Q_UNUSED(stateChanged);
     Q_UNUSED(spacing);
 
+    const QmlProfilerRangeModel *model = qobject_cast<const QmlProfilerRangeModel *>(
+                renderer->model());
+
     BindingLoopsRenderPassState *state;
-    if (oldState == 0)
+    if (oldState == 0) {
         state = new BindingLoopsRenderPassState;
-    else
+        state->m_expandedRows.reserve(model->expandedRowCount());
+        for (int i = 0; i < model->expandedRowCount(); ++i)
+            state->m_expandedRows << new QSGNode;
+        state->m_collapsedOverlay = new QSGNode;
+    } else {
         state = static_cast<BindingLoopsRenderPassState *>(oldState);
+    }
 
-    const QmlProfilerRangeModel *model = qobject_cast<const QmlProfilerRangeModel *>(
-                renderer->model());
     if (!model)
         return state;
 
-    if (state->expandedRows.isEmpty()) {
-        state->expandedRows.reserve(model->expandedRowCount());
-        for (int i = 0; i < model->expandedRowCount(); ++i)
-            state->expandedRows << new QSGNode;
-    }
-    if (state->collapsedOverlay == 0)
-        state->collapsedOverlay = new QSGNode;
-
     if (indexFrom < 0 || indexTo > model->count())
         return state;
 
diff --git a/src/plugins/qmlprofiler/timelineitemsrenderpass.cpp b/src/plugins/qmlprofiler/timelineitemsrenderpass.cpp
index 9cf75718c428e1a8cb9a5dbdc63a5d80c176a4d4..e1b6fa3fdeee708277d6818cd99c60a0e7ec265c 100644
--- a/src/plugins/qmlprofiler/timelineitemsrenderpass.cpp
+++ b/src/plugins/qmlprofiler/timelineitemsrenderpass.cpp
@@ -61,6 +61,11 @@ struct TimelineItemsRenderPassState : public TimelineRenderPass::State {
     int indexFrom;
     int indexTo;
     TimelineItemsMaterial collapsedRowMaterial;
+
+    QVector<QSGNode *> m_expandedRows;
+    QVector<QSGNode *> m_collapsedRows;
+    const QVector<QSGNode *> &expandedRows() const { return m_expandedRows; }
+    const QVector<QSGNode *> &collapsedRows() const { return m_collapsedRows; }
 };
 
 struct OpaqueColoredPoint2DWithSize {
@@ -208,8 +213,9 @@ static void updateNodes(int from, int to, const TimelineRenderer *renderer,
     for (int i = 0; i < model->expandedRowCount(); ++i) {
         TimelineItemsGeometry &row = expandedPerRow[i];
         if (row.usedVertices > 0) {
-            row.allocate(&static_cast<TimelineExpandedRowNode *>(state->expandedRows[i])->material);
-            state->expandedRows[i]->appendChildNode(row.node);
+            row.allocate(&static_cast<TimelineExpandedRowNode *>(
+                             state->m_expandedRows[i])->material);
+            state->m_expandedRows[i]->appendChildNode(row.node);
         }
     }
 
@@ -217,7 +223,7 @@ static void updateNodes(int from, int to, const TimelineRenderer *renderer,
         TimelineItemsGeometry &row = collapsedPerRow[i];
         if (row.usedVertices > 0) {
             row.allocate(&state->collapsedRowMaterial);
-            state->collapsedRows[i]->appendChildNode(row.node);
+            state->m_collapsedRows[i]->appendChildNode(row.node);
         }
     }
 
@@ -292,13 +298,13 @@ TimelineRenderPass::State *TimelineItemsRenderPass::update(const TimelineRendere
     state->collapsedRowMaterial.setSelectedItem(selectedItem);
     state->collapsedRowMaterial.setSelectionColor(selectionColor);
 
-    if (state->expandedRows.isEmpty()) {
-        state->expandedRows.reserve(model->expandedRowCount());
-        state->collapsedRows.reserve(model->collapsedRowCount());
+    if (state->m_expandedRows.isEmpty()) {
+        state->m_expandedRows.reserve(model->expandedRowCount());
+        state->m_collapsedRows.reserve(model->collapsedRowCount());
         for (int i = 0; i < model->expandedRowCount(); ++i)
-            state->expandedRows << new TimelineExpandedRowNode;
+            state->m_expandedRows << new TimelineExpandedRowNode;
         for (int i = 0; i < model->collapsedRowCount(); ++i)
-            state->collapsedRows << new QSGNode;
+            state->m_collapsedRows << new QSGNode;
     }
 
     if (indexFrom < 0 || indexTo > model->count())
@@ -325,7 +331,7 @@ TimelineRenderPass::State *TimelineItemsRenderPass::update(const TimelineRendere
     if (model->expanded()) {
         for (int row = 0; row < model->expandedRowCount(); ++row) {
             TimelineExpandedRowNode *rowNode = static_cast<TimelineExpandedRowNode *>(
-                        state->expandedRows[row]);
+                        state->m_expandedRows[row]);
             rowNode->material.setScale(
                         QVector2D(spacing / parentState->scale(),
                                   static_cast<qreal>(model->expandedRowHeight(row))) /
diff --git a/src/plugins/qmlprofiler/timelinenotesrenderpass.cpp b/src/plugins/qmlprofiler/timelinenotesrenderpass.cpp
index 21f478f412b96327c16750ad13b9e5bb63267be7..b6b332176779981db1d6982f9fd02add62c1ffbb 100644
--- a/src/plugins/qmlprofiler/timelinenotesrenderpass.cpp
+++ b/src/plugins/qmlprofiler/timelinenotesrenderpass.cpp
@@ -65,6 +65,11 @@ struct TimelineNotesRenderPassState : public TimelineRenderPass::State
 
     NotesMaterial material;
     QSGGeometry nullGeometry;
+    QSGGeometryNode *m_collapsedOverlay;
+    QVector<QSGNode *> m_expandedRows;
+
+    QSGNode *collapsedOverlay() const { return m_collapsedOverlay; }
+    const QVector<QSGNode *> &expandedRows() const { return m_expandedRows; }
 };
 
 const QSGGeometry::AttributeSet &NotesGeometry::point2DWithDistanceFromTop()
@@ -127,7 +132,7 @@ TimelineRenderPass::State *TimelineNotesRenderPass::update(const TimelineRendere
         collapsed << timelineIndex;
     }
 
-    QSGGeometryNode *collapsedNode = static_cast<QSGGeometryNode *>(state->collapsedOverlay);
+    QSGGeometryNode *collapsedNode = state->m_collapsedOverlay;
 
     if (collapsed.count() > 0) {
         collapsedNode->setGeometry(NotesGeometry::createGeometry(collapsed, model, parentState,
@@ -139,7 +144,7 @@ TimelineRenderPass::State *TimelineNotesRenderPass::update(const TimelineRendere
     }
 
     for (int row = 0; row < model->expandedRowCount(); ++row) {
-        QSGGeometryNode *rowNode = static_cast<QSGGeometryNode *>(state->expandedRows[row]);
+        QSGGeometryNode *rowNode = static_cast<QSGGeometryNode *>(state->m_expandedRows[row]);
         if (expanded[row].isEmpty()) {
             rowNode->setGeometry(&state->nullGeometry);
             rowNode->setFlag(QSGGeometryNode::OwnsGeometry, false);
@@ -157,10 +162,10 @@ TimelineNotesRenderPassState::TimelineNotesRenderPassState(int numExpandedRows)
     nullGeometry(NotesGeometry::point2DWithDistanceFromTop(), 0)
 {
     material.setFlag(QSGMaterial::Blending, true);
-    expandedRows.reserve(numExpandedRows);
+    m_expandedRows.reserve(numExpandedRows);
     for (int i = 0; i < numExpandedRows; ++i)
-        expandedRows << createNode();
-    collapsedOverlay = createNode();
+        m_expandedRows << createNode();
+    m_collapsedOverlay = createNode();
 }
 
 QSGGeometryNode *TimelineNotesRenderPassState::createNode()
diff --git a/src/plugins/qmlprofiler/timelinerenderer.cpp b/src/plugins/qmlprofiler/timelinerenderer.cpp
index a9f6b7df317fb6df2232ccb3920d08d3432bf328..703c567fa87fba030d8cdb9080374d58e0925094 100644
--- a/src/plugins/qmlprofiler/timelinerenderer.cpp
+++ b/src/plugins/qmlprofiler/timelinerenderer.cpp
@@ -270,10 +270,10 @@ QSGNode *TimelineRenderer::updatePaintNode(QSGNode *node, UpdatePaintNodeData *u
             const TimelineRenderPass::State *passState = state->passState(pass);
             if (!passState)
                 continue;
-            if (passState->expandedOverlay)
-                state->expandedOverlayRoot()->appendChildNode(passState->expandedOverlay);
-            if (passState->collapsedOverlay)
-                state->collapsedOverlayRoot()->appendChildNode(passState->collapsedOverlay);
+            if (passState->expandedOverlay())
+                state->expandedOverlayRoot()->appendChildNode(passState->expandedOverlay());
+            if (passState->collapsedOverlay())
+                state->collapsedOverlayRoot()->appendChildNode(passState->collapsedOverlay());
         }
 
         int row = 0;
@@ -281,8 +281,11 @@ QSGNode *TimelineRenderer::updatePaintNode(QSGNode *node, UpdatePaintNodeData *u
             QSGTransformNode *rowNode = new QSGTransformNode;
             for (int pass = 0; pass < d->renderPasses.length(); ++pass) {
                 const TimelineRenderPass::State *passState = state->passState(pass);
-                if (passState && passState->expandedRows.length() > row) {
-                    QSGNode *rowChildNode = passState->expandedRows[row];
+                if (!passState)
+                    continue;
+                const QVector<QSGNode *> &rows = passState->expandedRows();
+                if (rows.length() > row) {
+                    QSGNode *rowChildNode = rows[row];
                     if (rowChildNode)
                         rowNode->appendChildNode(rowChildNode);
                 }
@@ -298,8 +301,11 @@ QSGNode *TimelineRenderer::updatePaintNode(QSGNode *node, UpdatePaintNodeData *u
             rowNode->setMatrix(matrix);
             for (int pass = 0; pass < d->renderPasses.length(); ++pass) {
                 const TimelineRenderPass::State *passState = state->passState(pass);
-                if (passState && passState->collapsedRows.length() > row) {
-                    QSGNode *rowChildNode = passState->collapsedRows[row];
+                if (!passState)
+                    continue;
+                const QVector<QSGNode *> &rows = passState->collapsedRows();
+                if (rows.length() > row) {
+                    QSGNode *rowChildNode = rows[row];
                     if (rowChildNode)
                         rowNode->appendChildNode(rowChildNode);
                 }
diff --git a/src/plugins/qmlprofiler/timelinerenderpass.cpp b/src/plugins/qmlprofiler/timelinerenderpass.cpp
index 18f0cd819f1d810f07ae530eb9043d1ea578493d..94bbb79acb7fa39c61dc311c3d89168192cef7cd 100644
--- a/src/plugins/qmlprofiler/timelinerenderpass.cpp
+++ b/src/plugins/qmlprofiler/timelinerenderpass.cpp
@@ -32,4 +32,28 @@
 
 namespace Timeline {
 
+const QVector<QSGNode *> &TimelineRenderPass::State::expandedRows() const
+{
+    static const QVector<QSGNode *> empty;
+    return empty;
+}
+
+const QVector<QSGNode *> &TimelineRenderPass::State::collapsedRows() const
+{
+    static const QVector<QSGNode *> empty;
+    return empty;
+}
+
+QSGNode *TimelineRenderPass::State::expandedOverlay() const
+{
+    return 0;
+}
+
+QSGNode *TimelineRenderPass::State::collapsedOverlay() const
+{
+    return 0;
+}
+
+TimelineRenderPass::~TimelineRenderPass() {}
+
 } // namespace Timeline
diff --git a/src/plugins/qmlprofiler/timelinerenderpass.h b/src/plugins/qmlprofiler/timelinerenderpass.h
index 9eb34d4aa91324f0d64ad48473f309ed6f5d0db3..89c1171c3cfabae0923cc00546d24bf483a472bd 100644
--- a/src/plugins/qmlprofiler/timelinerenderpass.h
+++ b/src/plugins/qmlprofiler/timelinerenderpass.h
@@ -41,16 +41,15 @@ class TimelineRenderState;
 
 class TimelineRenderPass {
 public:
-    struct State {
-        State() : expandedOverlay(0), collapsedOverlay(0) {}
-
-        QVector<QSGNode *> expandedRows;
-        QVector<QSGNode *> collapsedRows;
-        QSGNode *expandedOverlay;
-        QSGNode *collapsedOverlay;
+    class State {
+    public:
+        virtual const QVector<QSGNode *> &expandedRows() const;
+        virtual const QVector<QSGNode *> &collapsedRows() const;
+        virtual QSGNode *expandedOverlay() const;
+        virtual QSGNode *collapsedOverlay() const;
     };
 
-    virtual ~TimelineRenderPass() {}
+    virtual ~TimelineRenderPass();
     virtual State *update(const TimelineRenderer *renderer, const TimelineRenderState *parentState,
                           State *state, int indexFrom, int indexTo, bool stateChanged,
                           qreal spacing) const = 0;
diff --git a/src/plugins/qmlprofiler/timelineselectionrenderpass.cpp b/src/plugins/qmlprofiler/timelineselectionrenderpass.cpp
index b64ee8a0c952c0e70b33a8890601c1f9df67b14f..10b674fccea0ae98b4cfecb62106f6a74901478d 100644
--- a/src/plugins/qmlprofiler/timelineselectionrenderpass.cpp
+++ b/src/plugins/qmlprofiler/timelineselectionrenderpass.cpp
@@ -47,24 +47,34 @@ QSGSimpleRectNode *createSelectionNode()
     return selectionNode;
 }
 
+struct TimelineSelectionRenderPassState : public TimelineRenderPass::State {
+    QSGSimpleRectNode *m_expandedOverlay;
+    QSGSimpleRectNode *m_collapsedOverlay;
+
+    QSGNode *expandedOverlay() const { return m_expandedOverlay; }
+    QSGNode *collapsedOverlay() const { return m_collapsedOverlay; }
+};
+
 TimelineRenderPass::State *TimelineSelectionRenderPass::update(const TimelineRenderer *renderer,
-        const TimelineRenderState *parentState, State *state, int firstIndex, int lastIndex,
+        const TimelineRenderState *parentState, State *oldState, int firstIndex, int lastIndex,
         bool stateChanged, qreal spacing) const
 {
     Q_UNUSED(stateChanged);
 
-    if (state == 0)
-        state = new TimelineRenderPass::State;
+    TimelineSelectionRenderPassState *state;
 
-    if (state->expandedOverlay == 0) {
-        state->expandedOverlay = createSelectionNode();
-        state->collapsedOverlay = createSelectionNode();
+    if (oldState == 0) {
+        state = new TimelineSelectionRenderPassState;
+        state->m_expandedOverlay = createSelectionNode();
+        state->m_collapsedOverlay = createSelectionNode();
+    } else {
+        state = static_cast<TimelineSelectionRenderPassState *>(oldState);
     }
 
     const TimelineModel *model = renderer->model();
     QSGSimpleRectNode *selectionNode = static_cast<QSGSimpleRectNode *>(model->expanded() ?
-                                                                        state->expandedOverlay :
-                                                                        state->collapsedOverlay);
+                                                                        state->m_expandedOverlay :
+                                                                        state->m_collapsedOverlay);
 
     QSGSimpleRectNode *child = static_cast<QSGSimpleRectNode *>(selectionNode->firstChild());
     int selectedItem = renderer->selectedItem();