[sksg] More inval fixes

Backpedal on node/reval-time-determined damage: nodes cannot control
the invalidation order, and shared descendants may be revalidated before
a particular ancestor gets to query their state - thus making any
decisions based on that invalid.

Instead, apply damage suppression at invalidation time, based on node
type/traits.  Node types which don't generate direct damage are marked
as such, and the invalidation logic bubbles damage past them, until it
finds a valid damage receiver.

Nodes which currently suppress damage:

 - PaintNode    (and subclasses)
 - GeometryNode (and subclasses)
 - Matrix

TBR=
Change-Id: I843e683e64cb6253d8c26d8397c44d02a7d6026f
Reviewed-on: https://skia-review.googlesource.com/91421
Reviewed-by: Florin Malita <fmalita@chromium.org>
Commit-Queue: Florin Malita <fmalita@chromium.org>

1 files changed, 75 insertions, 3 deletions

diff --git a/tests/SGTest.cpp b/tests/SGTest.cpp
index 64b83b5bf8..d51f70be59 100644
--- a/tests/SGTest.cpp
+++ b/tests/SGTest.cpp
@@ -37,8 +37,9 @@ static void check_inval(skiatest::Reporter* reporter, const sk_sp<sksg::Node>& r
     REPORTER_ASSERT(reporter, ic.bounds() == expected_inval_bounds);
 
     if (expected_damage) {
-        REPORTER_ASSERT(reporter, expected_damage->size() == SkTo<size_t>(ic.end() - ic.begin()));
-        for (size_t i = 0; i < expected_damage->size(); ++i) {
+        const auto damage_count = SkTo<size_t>(ic.end() - ic.begin());
+        REPORTER_ASSERT(reporter, expected_damage->size() == damage_count);
+        for (size_t i = 0; i < std::min(expected_damage->size(), damage_count); ++i) {
             const auto r1 = (*expected_damage)[i],
                        r2 = ic.begin()[i];
             if (0) {
@@ -51,7 +52,7 @@ static void check_inval(skiatest::Reporter* reporter, const sk_sp<sksg::Node>& r
     }
 }
 
-DEF_TEST(SGInvalidation, reporter) {
+static void inval_test1(skiatest::Reporter* reporter) {
     auto color  = sksg::Color::Make(0xff000000);
     auto r1     = sksg::Rect::Make(SkRect::MakeWH(100, 100)),
          r2     = sksg::Rect::Make(SkRect::MakeWH(100, 100));
@@ -121,4 +122,75 @@ DEF_TEST(SGInvalidation, reporter) {
     }
 }
 
+static void inval_test2(skiatest::Reporter* reporter) {
+    auto color = sksg::Color::Make(0xff000000);
+    auto rect  = sksg::Rect::Make(SkRect::MakeWH(100, 100));
+    auto m1    = sksg::Matrix::Make(SkMatrix::I()),
+         m2    = sksg::Matrix::Make(SkMatrix::I(), m1);
+    auto t1    = sksg::Transform::Make(sksg::Draw::Make(rect, color), m2),
+         t2    = sksg::Transform::Make(sksg::Draw::Make(rect, color), m1);
+    auto root  = sksg::Group::Make();
+    root->addChild(t1);
+    root->addChild(t2);
+
+    {
+        // Initial revalidation.
+        check_inval(reporter, root,
+                    SkRect::MakeWH(100, 100),
+                    SkRect::MakeLargestS32(),
+                    nullptr);
+    }
+
+    {
+        // Update the shared color.
+        color->setColor(0xffff0000);
+        std::vector<SkRect> damage = { {0, 0, 100, 100}, { 0, 0, 100, 100} };
+        check_inval(reporter, root,
+                    SkRect::MakeWH(100, 100),
+                    SkRect::MakeWH(100, 100),
+                    &damage);
+    }
+
+    {
+        // Update m2.
+        m2->setMatrix(SkMatrix::MakeScale(2, 2));
+        std::vector<SkRect> damage = { {0, 0, 100, 100}, { 0, 0, 200, 200} };
+        check_inval(reporter, root,
+                    SkRect::MakeWH(200, 200),
+                    SkRect::MakeWH(200, 200),
+                    &damage);
+    }
+
+    {
+        // Update shared m1.
+        m1->setMatrix(SkMatrix::MakeTrans(100, 100));
+        std::vector<SkRect> damage = { {   0,   0, 200, 200},   // draw1 prev bounds
+                                       { 100, 100, 300, 300},   // draw1 new bounds
+                                       {   0,   0, 100, 100},   // draw2 prev bounds
+                                       { 100, 100, 200, 200} }; // draw2 new bounds
+        check_inval(reporter, root,
+                    SkRect::MakeLTRB(100, 100, 300, 300),
+                    SkRect::MakeLTRB(  0,   0, 300, 300),
+                    &damage);
+    }
+
+    {
+        // Update shared rect.
+        rect->setR(50);
+        std::vector<SkRect> damage = { { 100, 100, 300, 300},   // draw1 prev bounds
+                                       { 100, 100, 200, 300},   // draw1 new bounds
+                                       { 100, 100, 200, 200},   // draw2 prev bounds
+                                       { 100, 100, 150, 200} }; // draw2 new bounds
+        check_inval(reporter, root,
+                    SkRect::MakeLTRB(100, 100, 200, 300),
+                    SkRect::MakeLTRB(100, 100, 300, 300),
+                    &damage);
+    }
+}
+
+DEF_TEST(SGInvalidation, reporter) {
+    inval_test1(reporter);
+    inval_test2(reporter);
+}
+
 #endif // !defined(SK_BUILD_FOR_GOOGLE3)