clutter: Emit ::resource-scale-changed outside the stage-views walk.

update_resource_scale() emitted the signal from inside the recursive
clutter_actor_update_stage_views() traversal, so handlers that rebuild
content — st_icon_update()'s destroy + add_child — modified the actor
tree from within the layout operation, and the new child tripped "Can't
update stage views ... needs an allocation" before it could be
allocated. Reproducible on any non-primary monitor whose scale differs
from the stage's max.

Keep the resource_scale assignment in the walk so parents resolve before
children guess from them, and queue only the emission, draining it once
the walk has returned and before the actor_needs_immediate_relayout
check.

Author: mtwebster

clutter/clutter/clutter-actor-private.h

@@ -316,6 +316,7 @@ void                            _clutter_actor_queue_only_relayout
 void                            clutter_actor_clear_stage_views_recursive               (ClutterActor *actor);
 
 float                           clutter_actor_get_real_resource_scale                   (ClutterActor *actor);
+void                            clutter_actor_emit_resource_scale_changed               (ClutterActor *actor);
 
 ClutterPaintNode *              clutter_actor_create_texture_paint_node                 (ClutterActor *self,
                                                                                          CoglTexture  *texture);

clutter/clutter/clutter-actor.c

@@ -17873,7 +17873,20 @@ update_resource_scale (ClutterActor *self,
     return;
 
   if (ceilf (old_resource_scale) != ceilf (priv->resource_scale))
-    g_signal_emit (self, actor_signals[RESOURCE_SCALE_CHANGED], 0);
+    {
+      ClutterActor *stage = _clutter_actor_get_stage_internal (self);
+
+      if (stage != NULL)
+        clutter_stage_queue_resource_scale_change (CLUTTER_STAGE (stage), self);
+      else
+        clutter_actor_emit_resource_scale_changed (self);
+    }
+}
+
+void
+clutter_actor_emit_resource_scale_changed (ClutterActor *self)
+{
+  g_signal_emit (self, actor_signals[RESOURCE_SCALE_CHANGED], 0);
 }
 
 void

clutter/clutter/clutter-stage-private.h

@@ -143,6 +143,9 @@ void            clutter_stage_queue_actor_relayout      (ClutterStage *stage,
 void clutter_stage_dequeue_actor_relayout (ClutterStage *stage,
                                            ClutterActor *actor);
 
+void clutter_stage_queue_resource_scale_change (ClutterStage *stage,
+                                                ClutterActor *actor);
+
 GList * clutter_stage_get_views_for_rect (ClutterStage          *stage,
                                           const graphene_rect_t *rect);
 

clutter/clutter/clutter-stage.c

@@ -129,6 +129,7 @@ struct _ClutterStagePrivate
   ClutterPlane current_clip_planes[4];
 
   GSList *pending_relayouts;
+  GPtrArray *pending_resource_scale_changes;
   GList *pending_queue_redraws;
 
   gint sync_delay;
@@ -1382,6 +1383,47 @@ clutter_stage_dequeue_actor_relayout (ClutterStage *stage,
     }
 }
 
+void
+clutter_stage_queue_resource_scale_change (ClutterStage *stage,
+                                           ClutterActor *actor)
+{
+  ClutterStagePrivate *priv = stage->priv;
+
+  g_ptr_array_add (priv->pending_resource_scale_changes, g_object_ref (actor));
+}
+
+/* Resource scales are resolved while walking the actor tree, but handlers of
+ * ::resource-scale-changed routinely rebuild content and add children, which
+ * must not happen from inside that walk. Emit once the walk has finished.
+ */
+static void
+flush_resource_scale_changes (ClutterStage *stage)
+{
+  ClutterStagePrivate *priv = stage->priv;
+  g_autoptr (GPtrArray) changes = NULL;
+  unsigned int i;
+
+  if (priv->pending_resource_scale_changes->len == 0)
+    return;
+
+  changes = g_steal_pointer (&priv->pending_resource_scale_changes);
+  priv->pending_resource_scale_changes =
+    g_ptr_array_new_with_free_func (g_object_unref);
+
+  for (i = 0; i < changes->len; i++)
+    {
+      ClutterActor *actor = g_ptr_array_index (changes, i);
+
+      if (CLUTTER_ACTOR_IN_DESTRUCTION (actor))
+        continue;
+
+      if (clutter_actor_get_stage (actor) != CLUTTER_ACTOR (stage))
+        continue;
+
+      clutter_actor_emit_resource_scale_changed (actor);
+    }
+}
+
 void
 _clutter_stage_maybe_relayout (ClutterActor *actor)
 {
@@ -1551,6 +1593,7 @@ update_actor_stage_views (ClutterStage *stage)
   for (phase = 0; phase < 2; phase++)
     {
       clutter_actor_update_stage_views (actor, phase);
+      flush_resource_scale_changes (stage);
 
       if (!priv->actor_needs_immediate_relayout)
         break;
@@ -2048,6 +2091,8 @@ clutter_stage_dispose (GObject *object)
                      (GDestroyNotify) g_object_unref);
   priv->pending_relayouts = NULL;
 
+  g_clear_pointer (&priv->pending_resource_scale_changes, g_ptr_array_unref);
+
   /* this will release the reference on the stage */
   stage_manager = clutter_stage_manager_get_default ();
   _clutter_stage_manager_remove_stage (stage_manager, stage);
@@ -2454,6 +2499,9 @@ clutter_stage_init (ClutterStage *self)
   clutter_actor_set_background_color (CLUTTER_ACTOR (self),
                                       &default_stage_color);
 
+  priv->pending_resource_scale_changes =
+    g_ptr_array_new_with_free_func (g_object_unref);
+
   clutter_stage_queue_actor_relayout (self, CLUTTER_ACTOR (self));
 
   clutter_actor_set_reactive (CLUTTER_ACTOR (self), TRUE);