More explicit approach to grouping strategy destruction vs. group uncollapse.

Avoids ungrouping while GroupManager is destroyed and unnecessary
work in connected visualizations, and in practice a crash in Task
Manager from the ungroup model transaction hitting a half-destroyed
applet.

BUG:334772

libtaskmanager/abstractgroupingstrategy.cpp

@@ -34,13 +34,15 @@ class AbstractGroupingStrategy::Private
 {
 public:
     Private()
-        : type(GroupManager::NoGrouping) {
+        : type(GroupManager::NoGrouping)
+        , destroyGroupsOnDestruction(true) {
     }
 
     GroupManager *groupManager;
     QStringList usedNames;
     QList<TaskGroup*> createdGroups;
     GroupManager::TaskGroupingStrategy type;
+    bool destroyGroupsOnDestruction : 1;
 };
 
 AbstractGroupingStrategy::AbstractGroupingStrategy(GroupManager *groupManager)
@@ -52,17 +54,26 @@ AbstractGroupingStrategy::AbstractGroupingStrategy(GroupManager *groupManager)
 
 AbstractGroupingStrategy::~AbstractGroupingStrategy()
 {
-    destroy();
+    if (d->destroyGroupsOnDestruction) {
-    qDeleteAll(d->createdGroups);
+        destroyGroups();
+        qDeleteAll(d->createdGroups);
+    }
+
     delete d;
 }
 
-void AbstractGroupingStrategy::destroy()
+bool AbstractGroupingStrategy::destroyGroupsOnDestruction() const
 {
-    if (!d->groupManager) {
+    return d->destroyGroupsOnDestruction;
-        return;
+}
-    }
 
+void AbstractGroupingStrategy::setDestroyGroupsOnDestruction(bool destroy)
+{
+    d->destroyGroupsOnDestruction = destroy;
+}
+
+void AbstractGroupingStrategy::destroyGroups()
+{
     // cleanup all created groups
     foreach (TaskGroup * group, d->createdGroups) {
         disconnect(group, 0, this, 0);
@@ -84,9 +95,6 @@ void AbstractGroupingStrategy::destroy()
     foreach (TaskGroup * group, d->createdGroups) {
         emit groupRemoved(group);
     }
-
-    d->groupManager = 0;
-    deleteLater();
 }
 
 GroupManager::TaskGroupingStrategy AbstractGroupingStrategy::type() const

libtaskmanager/abstractgroupingstrategy.h

@@ -47,7 +47,23 @@ public:
     AbstractGroupingStrategy(GroupManager *groupManager);
     virtual ~AbstractGroupingStrategy();
 
-    void destroy();
+    /**
+     * Whether the grouping strategy will undo the current group topology
+     * when it is destroyed.
+     *
+     * See also destroyGroups().
+     */
+    bool destroyGroupsOnDestruction() const;
+
+    /**
+     * Setting this to false prevents the grouping strategy from undoing
+     * the current group toplogy when it is destroyed. This is mostly
+     * useful to avoid unnecessary work during shutdown.
+     *
+     * See also destroyGroups().
+     */
+    void setDestroyGroupsOnDestruction(bool destroy);
+
 
     /** Handles a new item */
     virtual void handleItem(AbstractGroupableItem *) = 0;
@@ -106,6 +122,9 @@ Q_SIGNALS:
     void groupRemoved(TaskGroup*);
 
 protected Q_SLOTS:
+    /** Uncollapse all groups into the root group. */
+    void destroyGroups();
+
     /** Adds all group members to the parentgroup of group and removes the group */
     virtual void closeGroup(TaskGroup *group);
 

libtaskmanager/groupmanager.cpp

@@ -172,8 +172,12 @@ GroupManager::GroupManager(QObject *parent)
 GroupManager::~GroupManager()
 {
     TaskManager::self()->setTrackGeometry(false, d->configToken);
+
     delete d->abstractSortingStrategy;
+
+    d->abstractGroupingStrategy->setDestroyGroupsOnDestruction(false);
     delete d->abstractGroupingStrategy;
+
     delete d;
 }
 
@@ -1256,7 +1260,7 @@ void GroupManager::setGroupingStrategy(TaskGroupingStrategy strategy)
 
     if (d->abstractGroupingStrategy) {
         disconnect(d->abstractGroupingStrategy, 0, this, 0);
-        d->abstractGroupingStrategy->destroy();
+        delete d->abstractGroupingStrategy;
         d->abstractGroupingStrategy = 0;
     }