Revert of 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 traverseNonCompositingDescendantsInPaintOrder(LayoutObject&, const LayoutObjectTraversalFunctor&);
+void traverseNonCompositingDescendants(LayoutObject&, const LayoutObjectTraversalFunctor&);
 
 template <typename LayoutObjectTraversalFunctor>
-void traverseNonCompositingDescendantsBelongingToAncestorPaintInvalidationContainer(LayoutObject& object, const LayoutObjectTraversalFunctor& functor)
+void findNonCompositedDescendantLayerToTraverse(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) {
-        if (!descendant->hasLayer() || !descendant->styleRef().isStacked()) {
-            // Case 1: The descendant is not stacked (or is stacked but has not been
-            // allocated a layer yet during style change), so either it's a paint invalidation
-            // container in the same situation as |object|, or its paint invalidation
-            // container is in such situation. Keep searching until a stacked layer is found.
+        // Case 1: If the descendant has no layer, keep searching until we find a layer.
+        if (!descendant->hasLayer()) {
             descendant = descendant->nextInPreOrder(&object);
-        } else if (!descendant->isPaintInvalidationContainer()) {
-            // Case 2: The descendant is stacked and is not composited.
-            // The invalidation container of its subtree is our ancestor,
-            // thus recur into the subtree.
-            traverseNonCompositingDescendantsInPaintOrder(*descendant, functor);
+            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()) {
+            traverseNonCompositingDescendants(*descendant, functor);
             descendant = descendant->nextInPreOrderAfterChildren(&object);
-        } else if (descendant->styleRef().isStackingContext()) {
-            // 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.
+            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);
-        } else {
-            // Case 4: The descendant is an invalidation container but not a stacking context.
-            // This is the same situation as |object|, thus keep searching.
-            descendant = descendant->nextInPreOrder(&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 traverseNonCompositingDescendantsInPaintOrder(LayoutObject& object, const LayoutObjectTraversalFunctor& functor)
+void traverseNonCompositingDescendants(LayoutObject& object, const LayoutObjectTraversalFunctor& functor)
 {
     functor(object);
     LayoutObject* descendant = object.nextInPreOrder(&object);
     while (descendant) {
         if (!descendant->isPaintInvalidationContainer()) {
             functor(*descendant);
             descendant = descendant->nextInPreOrder(&object);
-        } else if (descendant->styleRef().isStackingContext()) {
-            // 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.
+            continue;
+        }
+        if (descendant->styleRef().isStackingContext()) {
             descendant = descendant->nextInPreOrderAfterChildren(&object);
-        } else {
-            // If a paint invalidation container is not a stacking context,
-            // some of its descendants may belong to the parent container.
-            traverseNonCompositingDescendantsBelongingToAncestorPaintInvalidationContainer(*descendant, functor);
-            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);
+        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();
-    traverseNonCompositingDescendantsInPaintOrder(const_cast<LayoutObject&>(*this), [reason](LayoutObject& object) {
+    traverseNonCompositingDescendants(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();
-    traverseNonCompositingDescendantsInPaintOrder(*this, [&paintInvalidationContainer](LayoutObject& object) {
+    traverseNonCompositingDescendants(*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