Don't traverse non-stacked layer under composited child in traverseNonCompositingDescendants

third_party/WebKit/Source/core/layout/LayoutObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 3471 matching lines @@
 
 DisablePaintInvalidationStateAsserts::DisablePaintInvalidationStateAsserts()
     : m_disabler(&gDisablePaintInvalidationStateAsserts, true)
 {
 }
 
 namespace {
 
 // TODO(trchen): Use std::function<void, LayoutObject&> when available.
 template <typename LayoutObjectTraversalFunctor>
-void traverseNonCompositingDescendants(LayoutObject&, const LayoutObjectTraversalFunctor&);
+void traverseNonCompositingDescendantsInPaintOrder(LayoutObject&, const LayoutObjectTraversalFunctor&);
 
 template <typename LayoutObjectTraversalFunctor>
-void findNonCompositedDescendantLayerToTraverse(LayoutObject& object, const LayoutObjectTraversalFunctor& functor)
+void traverseNonCompositingDescendantsBelongingToAncestorPaintInvalidationContainer(LayoutObject& object, const LayoutObjectTraversalFunctor& functor)
 {
+    // |object| is a paint invalidation container but is not a stacking context, so the paint
+    // invalidation container of stacked descendants don't belong to |object| but belong to
+    // an ancestor. This function traverses all such descendants.
+    DCHECK(object.isPaintInvalidationContainer() && !object.styleRef().isStackingContext());
+
     LayoutObject* descendant = object.nextInPreOrder(&object);
     while (descendant) {
         // Case 1: If the descendant has no layer, keep searching until we find a layer.
         if (!descendant->hasLayer()) {

[trchen, 2016/08/04 23:34:55]

How about this:

// Case 1: If the descendant is not stacked, keep searching until a stacked one
is found.
if (!descendant->styleRef().isStacked()) {

[Xianzhu, 2016/08/05 00:27:07]

Done.

             descendant = descendant->nextInPreOrder(&object);
             continue;
         }
         // Case 2: The descendant has a layer and is not composited.
-        // The invalidation container of its subtree is our parent,
-        // thus recur into the subtree.
         if (!descendant->isPaintInvalidationContainer()) {

[trchen, 2016/08/04 23:34:55]

// Case 2: The descendant is stacked but not composited.
if (!descendant->isPaintInvalidationContainer()) {

[Xianzhu, 2016/08/05 00:27:07]

Done.

-            traverseNonCompositingDescendants(*descendant, functor);
-            descendant = descendant->nextInPreOrderAfterChildren(&object);
+            // Case 2a: The descendant is stacked. The invalidation container of
+            // its subtree is our ancestor, thus recur into the subtree.
+            if (descendant->styleRef().isStacked()) {
+                traverseNonCompositingDescendantsInPaintOrder(*descendant, functor);
+                descendant = descendant->nextInPreOrderAfterChildren(&object);
+                continue;
+            }
+            // Case 2b: The descendant is not stacked so its paint invalidation container
+            // is still |object|. Keep searching.
+            descendant = descendant->nextInPreOrder(&object);
             continue;
         }
         // Case 3: The descendant is an invalidation container and is a stacking context.
         // No objects in the subtree can have invalidation container outside of it,
         // thus skip the whole subtree.
         if (descendant->styleRef().isStackingContext()) {
             descendant = descendant->nextInPreOrderAfterChildren(&object);
             continue;
         }
         // Case 4: The descendant is an invalidation container but not a stacking context.
         // This is the same situation as the root, thus keep searching.
         descendant = descendant->nextInPreOrder(&object);
     }
 }
 
 template <typename LayoutObjectTraversalFunctor>
-void traverseNonCompositingDescendants(LayoutObject& object, const LayoutObjectTraversalFunctor& functor)
+void traverseNonCompositingDescendantsInPaintOrder(LayoutObject& object, const LayoutObjectTraversalFunctor& functor)
 {
     functor(object);
     LayoutObject* descendant = object.nextInPreOrder(&object);
     while (descendant) {
         if (!descendant->isPaintInvalidationContainer()) {
             functor(*descendant);
             descendant = descendant->nextInPreOrder(&object);
             continue;
         }
         if (descendant->styleRef().isStackingContext()) {
             descendant = descendant->nextInPreOrderAfterChildren(&object);
             continue;
         }
 
         // If a paint invalidation container is not a stacking context,
         // some of its descendants may belong to the parent container.
-        findNonCompositedDescendantLayerToTraverse(*descendant, functor);
+        traverseNonCompositingDescendantsBelongingToAncestorPaintInvalidationContainer(*descendant, functor);
         descendant = descendant->nextInPreOrderAfterChildren(&object);
     }
 }
 
 } // unnamed namespace
 
 void LayoutObject::invalidateDisplayItemClientsIncludingNonCompositingDescendants(PaintInvalidationReason reason) const
 {
     // This is valid because we want to invalidate the client in the display item list of the current backing.
     DisableCompositingQueryAsserts disabler;
 
     slowSetPaintingLayerNeedsRepaint();
-    traverseNonCompositingDescendants(const_cast<LayoutObject&>(*this), [reason](LayoutObject& object) {
+    traverseNonCompositingDescendantsInPaintOrder(const_cast<LayoutObject&>(*this), [reason](LayoutObject& object) {
         if (object.hasLayer() && toLayoutBoxModelObject(object).hasSelfPaintingLayer())
             toLayoutBoxModelObject(object).layer()->setNeedsRepaint();
         object.invalidateDisplayItemClients(reason);
     });
 }
 
 void LayoutObject::invalidatePaintOfPreviousPaintInvalidationRect(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason reason)
 {
     // It's caller's responsibility to ensure enclosingSelfPaintingLayer's needsRepaint is set.
     // Don't set the flag here because getting enclosingSelfPaintLayer has cost and the caller can use
@@ skipping 12 matching lines @@
     // Clear previous paint invalidation rect on the original paint invalidation container to avoid
     // under-invalidation if the new paint invalidation rect on the new paint invalidation container
     // happens to be the same as the old one.
     clearPreviousPaintInvalidationRects();
 }
 
 void LayoutObject::invalidatePaintIncludingNonCompositingDescendants()
 {
     // Since we're only painting non-composited layers, we know that they all share the same paintInvalidationContainer.
     const LayoutBoxModelObject& paintInvalidationContainer = containerForPaintInvalidation();
-    traverseNonCompositingDescendants(*this, [&paintInvalidationContainer](LayoutObject& object) {
+    traverseNonCompositingDescendantsInPaintOrder(*this, [&paintInvalidationContainer](LayoutObject& object) {
         if (object.hasLayer())
             toLayoutBoxModelObject(object).layer()->setNeedsRepaint();
         object.invalidatePaintOfPreviousPaintInvalidationRect(paintInvalidationContainer, PaintInvalidationSubtree);
     });
 }
 
 void LayoutObject::setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants()
 {
     // Clear first because PaintInvalidationSubtree overrides other full paint invalidation reasons.
     clearShouldDoFullPaintInvalidation();
@@ skipping 74 matching lines @@
         const blink::LayoutObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showLayoutTreeAndMark(object1, "*", object2, "-", 0);
     } else {
         WTFLogAlways("%s", "Cannot showLayoutTree. Root is (nil)");
     }
 }
 
 #endif