Only invalidate alive children

osu.Framework.Benchmarks/BenchmarkInvalidationWithManyNotAlive.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using BenchmarkDotNet.Attributes;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osuTK;
+
+namespace osu.Framework.Benchmarks
+{
+    public class BenchmarkInvalidationWithManyNotAlive : GameBenchmark
+    {
+        [Test]
+        [Benchmark]
+        public void RunFrame() => RunSingleFrame();
+
+        protected override Game CreateGame() => new TestGame();
+
+        private class TestGame : Game
+        {
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                var container = new FillFlowContainer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                };
+
+                for (int i = 0; i < 50000; i++)
+                {
+                    container.Add(new Box
+                    {
+                        Size = new Vector2(10),
+                        LifetimeStart = i > 10000 ? double.MaxValue : double.MinValue
+                    });
+                }
+
+                Add(container);
+
+                container.Spin(200, RotationDirection.Clockwise);
+            }
+        }
+    }
+}

osu.Framework.Benchmarks/BenchmarkMakeChildAlive.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using BenchmarkDotNet.Attributes;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Shapes;
+
+namespace osu.Framework.Benchmarks
+{
+    public class BenchmarkMakeChildAlive : GameBenchmark
+    {
+        [Test]
+        [Benchmark]
+        public void RunFrame() => RunSingleFrame();
+
+        protected override Game CreateGame() => new TestGame();
+
+        private class TestGame : Game
+        {
+            private readonly Box child;
+
+            public TestGame()
+            {
+                child = new Box { RelativeSizeAxes = Axes.Both };
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                Clear(false);
+                Add(child);
+            }
+        }
+    }
+}

osu.Framework.Benchmarks/BenchmarkSpinningParentWithManyAlive.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using BenchmarkDotNet.Attributes;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osuTK;
+
+namespace osu.Framework.Benchmarks
+{
+    public class BenchmarkSpinningParentWithManyAlive : GameBenchmark
+    {
+        [Test]
+        [Benchmark]
+        public void RunFrame() => RunSingleFrame();
+
+        protected override Game CreateGame() => new TestGame();
+
+        private class TestGame : Game
+        {
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                var container = new FillFlowContainer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                };
+
+                for (int i = 0; i < 10000; i++)
+                    container.Add(new Box { Size = new Vector2(10) });
+
+                Add(container);
+
+                container.Spin(200, RotationDirection.Clockwise);
+            }
+        }
+    }
+}

osu.Framework.Tests/Layout/TestSceneContainerLayout.cs

···
             AddAssert("parent only invalidated with size", () => invalidation == Invalidation.DrawSize);
         }
 
+        /// <summary>
+        /// Tests that a child is not invalidated by its parent when not alive.
+        /// </summary>
+        [Test]
+        public void TestChildNotInvalidatedWhenNotAlive()
+        {
+            Container parent = null;
+            bool invalidated = false;
+
+            AddStep("create test", () =>
+            {
+                Drawable child;
+
+                Child = parent = new Container
+                {
+                    Size = new Vector2(200),
+                    Child = child = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        LifetimeStart = double.MaxValue
+                    }
+                };
+
+                // Trigger a validation of draw size.
+                Assert.That(child.DrawSize, Is.EqualTo(new Vector2(200)));
+
+                child.Invalidated += _ => invalidated = true;
+            });
+
+            AddStep("resize parent", () => parent.Size = new Vector2(400));
+            AddAssert("child not invalidated", () => !invalidated);
+        }
+
+        /// <summary>
+        /// Tests that a loaded child is invalidated when it becomes alive.
+        /// </summary>
+        [Test]
+        public void TestChildInvalidatedWhenMadeAlive()
+        {
+            Container parent = null;
+            Drawable child = null;
+            bool invalidated = false;
+
+            AddStep("create test", () =>
+            {
+                Child = parent = new Container
+                {
+                    Size = new Vector2(200),
+                    Child = child = new Box { RelativeSizeAxes = Axes.Both }
+                };
+            });
+
+            AddStep("make child dead", () =>
+            {
+                child.LifetimeStart = double.MaxValue;
+                child.Invalidated += _ => invalidated = true;
+            });
+
+            // See above: won't cause an invalidation
+            AddStep("resize parent", () => parent.Size = new Vector2(400));
+
+            AddStep("make child alive", () => child.LifetimeStart = double.MinValue);
+            AddAssert("child invalidated", () => invalidated);
+
+            // Final check to make sure that the correct invalidation occurred
+            AddAssert("child size matches parent", () => child.DrawSize == parent.Size);
+        }
+
         private class TestBox1 : Box
         {
             public override bool RemoveWhenNotAlive => false;

osu.Framework/Graphics/Containers/CompositeDrawable.cs

···
 
             ChildBecameAlive?.Invoke(child);
 
+            // Invalidations on non-alive children are blocked, so they must be invalidated once when they become alive.
+            child.Invalidate(source: InvalidationSource.Parent);
+
+            // Notify ourselves that a child has become alive.
             Invalidate(Invalidation.Presence, InvalidationSource.Child);
         }
 
···
                 removed = true;
             }
 
+            // Notify ourselves that a child has died.
             Invalidate(Invalidation.Presence, InvalidationSource.Child);
 
             return removed;
···
             if (source == InvalidationSource.Child)
                 return anyInvalidated;
 
-            for (int i = 0; i < internalChildren.Count; ++i)
+            for (int i = 0; i < aliveInternalChildren.Count; ++i)
             {
-                Drawable c = internalChildren[i];
+                Drawable c = aliveInternalChildren[i];
 
                 Invalidation childInvalidation = invalidation;
                 if ((invalidation & Invalidation.RequiredParentSizeToFit) > 0)