commit c14f144484eff57f6861766510876d83b9046fa6
author Florin Malita <fmalita@chromium.org> Fri Jan 05 11:32:31 2018 -0500
committer Skia Commit-Bot <skia-commit-bot@chromium.org> Fri Jan 05 18:08:31 2018 +0000
tree 2f363a7339c8995821cbd5755afdb9a2fda9a980
parent f470b7ecf0ad3910e96414a3d93db61c422ba917

[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>

experimental/sksg/SkSGNode.cpp

diff --git a/experimental/sksg/SkSGNode.cpp b/experimental/sksg/SkSGNode.cpp
index fc4d278..768fdfa 100644
--- a/experimental/sksg/SkSGNode.cpp
+++ b/experimental/sksg/SkSGNode.cpp
@@ -38,10 +38,11 @@
     if (traversal_guard.wasSet())                        \
         return
 
-Node::Node()
+Node::Node(uint32_t invalTraits)
     : fInvalReceiver(nullptr)
     , fBounds(SkRect::MakeLargestS32())
-    , fFlags(kInvalSelf_Flag | kInvalDescendant_Flag) {}
+    , fInvalTraits(invalTraits)
+    , fFlags(kInvalidated_Flag) {}
 
 Node::~Node() {
     if (fFlags & kReceiverArray_Flag) {
@@ -99,24 +100,24 @@
     }
 }
 
-void Node::invalidateSelf() {
-    if (this->hasSelfInval()) {
+void Node::invalidate(bool damageBubbling) {
+    TRAVERSAL_GUARD;
+
+    if (this->hasInval() && (!damageBubbling || (fFlags & kDamage_Flag))) {
+        // All done.
         return;
     }
 
-    fFlags |= kInvalSelf_Flag;
-    this->invalidateAncestors();
-}
+    if (damageBubbling && !(fInvalTraits & kBubbleDamage_Trait)) {
+        // Found a damage receiver.
+        fFlags |= kDamage_Flag;
+        damageBubbling = false;
+    }
 
-void Node::invalidateAncestors() {
-    TRAVERSAL_GUARD;
+    fFlags |= kInvalidated_Flag;
 
     forEachInvalReceiver([&](Node* receiver) {
-        if (receiver->hasDescendantInval()) {
-            return;
-        }
-        receiver->fFlags |= kInvalDescendant_Flag;
-        receiver->invalidateAncestors();
+        receiver->invalidate(damageBubbling);
     });
 }
 
@@ -127,21 +128,21 @@
         return fBounds;
     }
 
-    const auto result     = this->onRevalidate(ic, ctm);
-    const auto selfDamage = result.fDamage == Damage::kForceSelf ||
-                            (this->hasSelfInval() && result.fDamage != Damage::kBlockSelf);
+    SkRect prevBounds;
+    if (fFlags & kDamage_Flag) {
+        prevBounds = fBounds;
+    }
 
-    if (selfDamage) {
-        // old bounds
-        ic->inval(fBounds, ctm);
-        if (result.fBounds != fBounds) {
-            // new bounds
-            ic->inval(result.fBounds, ctm);
+    fBounds = this->onRevalidate(ic, ctm);
+
+    if (fFlags & kDamage_Flag) {
+        ic->inval(prevBounds, ctm);
+        if (fBounds != prevBounds) {
+            ic->inval(fBounds, ctm);
         }
     }
 
-    fBounds = result.fBounds;
-    fFlags &= ~(kInvalSelf_Flag | kInvalDescendant_Flag);
+    fFlags &= ~(kInvalidated_Flag | kDamage_Flag);
 
     return fBounds;
 }