Revert of Calculate paint invalidation rect for scrollbars

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 3280 matching lines @@
     return gModifyLayoutTreeStructureAnyState;
 }
 
 DisablePaintInvalidationStateAsserts::DisablePaintInvalidationStateAsserts()
     : m_disabler(gDisablePaintInvalidationStateAsserts, true)
 {
 }
 
 namespace {
 
-// TODO(trchen): Use std::function<void, LayoutObject&> when available.
-template <typename LayoutObjectTraversalFunctor>
+// TODO(trchen): Use std::function<void, LayoutObject&> and lambda when available.
+class LayoutObjectTraversalFunctor {
+public:
+    virtual void operator()(LayoutObject&) const = 0;
+};
+
 void traverseNonCompositingDescendants(LayoutObject&, const LayoutObjectTraversalFunctor&);
 
-template <typename LayoutObjectTraversalFunctor>
 void findNonCompositedDescendantLayerToTraverse(LayoutObject& object, const LayoutObjectTraversalFunctor& functor)
 {
     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()) {
             descendant = descendant->nextInPreOrder(&object);
             continue;
         }
         // Case 2: The descendant has a layer and is not composited.
@@ skipping 10 matching lines @@
         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)
 {
     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);
         descendant = descendant->nextInPreOrderAfterChildren(&object);
     }
 }
 
 } // unnamed namespace
 
-void LayoutObject::invalidateDisplayItemClientsIncludingNonCompositingDescendants(const LayoutBoxModelObject* paintInvalidationContainer, PaintInvalidationReason paintInvalidationReason, const LayoutRect* paintInvalidationRect) const
+void LayoutObject::invalidateDisplayItemClientForNonCompositingDescendantsOf(const LayoutObject& object) const
 {
+    // Not using enclosingCompositedContainer() directly because this object may be in an orphaned subtree.
+    PaintLayer* enclosingLayer = this->enclosingLayer();
+    if (!enclosingLayer)
+        return;
+
+    // TODO(wangxianzhu): This is a workaround for invalidation of detached custom scrollbar parts which can't find
+    // their own enclosing layers. May remove this when fixing crbug.com/547119 for scrollbars.
+    enclosingLayer->setNeedsRepaint();
+
     // This is valid because we want to invalidate the client in the display item list of the current backing.
     DisableCompositingQueryAsserts disabler;
-    if (!paintInvalidationContainer) {
-        // Not using enclosingCompositedContainer() directly because this object may be in an orphaned subtree.
-        PaintLayer* enclosingLayer = this->enclosingLayer();
-        if (!enclosingLayer)
-            return;
-        const PaintLayer* paintInvalidationLayer = enclosingLayer->enclosingLayerForPaintInvalidationCrossingFrameBoundaries();
-        if (!paintInvalidationLayer)
-            return;
-        paintInvalidationContainer = paintInvalidationLayer->layoutObject();
-    }
+    const PaintLayer* paintInvalidationLayer = enclosingLayer->enclosingLayerForPaintInvalidationCrossingFrameBoundaries();
+    if (!paintInvalidationLayer)
+        return;
 
-    traverseNonCompositingDescendants(const_cast<LayoutObject&>(*this), [&paintInvalidationContainer, paintInvalidationReason, paintInvalidationRect](LayoutObject& object) {
-        object.invalidateDisplayItemClients(*paintInvalidationContainer, paintInvalidationReason, paintInvalidationRect);
-    });
+    class Functor : public LayoutObjectTraversalFunctor {
+    public:
+        explicit Functor(const LayoutBoxModelObject& paintInvalidationContainer) : m_paintInvalidationContainer(paintInvalidationContainer) { }
+        void operator()(LayoutObject& object) const override
+        {
+            // TODO(wangxianzhu): Ensure correct bounds for the client will be or has been passed to PaintController. crbug.com/547119.
+            object.invalidateDisplayItemClients(m_paintInvalidationContainer, PaintInvalidationFull, nullptr);
+        }
+    private:
+        const LayoutBoxModelObject& m_paintInvalidationContainer;
+    };
+
+    const LayoutBoxModelObject& paintInvalidationContainer = *paintInvalidationLayer->layoutObject();
+    traverseNonCompositingDescendants(const_cast<LayoutObject&>(object), Functor(paintInvalidationContainer));
 }
 
 void LayoutObject::invalidatePaintOfPreviousPaintInvalidationRect(const LayoutBoxModelObject& paintInvalidationContainer, PaintInvalidationReason reason)
 {
     // These disablers are valid because we want to use the current compositing/invalidation status.
     DisablePaintInvalidationStateAsserts invalidationDisabler;
     DisableCompositingQueryAsserts compositingDisabler;
 
     LayoutRect invalidationRect = previousPaintInvalidationRect();
     adjustInvalidationRectForCompositedScrolling(invalidationRect, paintInvalidationContainer);
     invalidatePaintUsingContainer(paintInvalidationContainer, invalidationRect, PaintInvalidationLayer);
 
     // The PaintController may have changed. Pass the previous paint invalidation rect to the new PaintController.
     // The rect will be updated if it changes during the next paint invalidation.
     invalidateDisplayItemClients(paintInvalidationContainer, PaintInvalidationLayer, &invalidationRect);
 
     // This method may be used to invalidate paint of an object changing paint invalidation container.
     // 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.
     setPreviousPaintInvalidationRect(LayoutRect());
 }
 
 void LayoutObject::invalidatePaintIncludingNonCompositingDescendants()
 {
+    class Functor : public LayoutObjectTraversalFunctor {
+    public:
+        explicit Functor(const LayoutBoxModelObject& paintInvalidationContainer) : m_paintInvalidationContainer(paintInvalidationContainer) { }
+        void operator()(LayoutObject& object) const override
+        {
+            object.invalidatePaintOfPreviousPaintInvalidationRect(m_paintInvalidationContainer, PaintInvalidationLayer);
+        }
+    private:
+        const LayoutBoxModelObject& m_paintInvalidationContainer;
+    };
+
     // Since we're only painting non-composited layers, we know that they all share the same paintInvalidationContainer.
     const LayoutBoxModelObject& paintInvalidationContainer = containerForPaintInvalidationOnRootedTree();
-    traverseNonCompositingDescendants(*this, [&paintInvalidationContainer](LayoutObject& object) {
-        object.invalidatePaintOfPreviousPaintInvalidationRect(paintInvalidationContainer, PaintInvalidationLayer);
-    });
+    traverseNonCompositingDescendants(*this, Functor(paintInvalidationContainer));
 }
 
 // FIXME: If we had a flag to force invalidations in a whole subtree, we could get rid of this function (crbug.com/410097).
 void LayoutObject::setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants()
 {
+    class Functor : public LayoutObjectTraversalFunctor {
+    public:
+        void operator()(LayoutObject& object) const override
+        {
+            object.setShouldDoFullPaintInvalidation();
+        }
+    };
+
     // Need to access the current compositing status.
     DisableCompositingQueryAsserts disabler;
-    traverseNonCompositingDescendants(*this, [](LayoutObject& object) {
-        object.setShouldDoFullPaintInvalidation();
-    });
+    traverseNonCompositingDescendants(*this, Functor());
 }
 
 void LayoutObject::invalidatePaintIncludingNonSelfPaintingLayerDescendants(const LayoutBoxModelObject& paintInvalidationContainer)
 {
     invalidatePaintOfPreviousPaintInvalidationRect(paintInvalidationContainer, PaintInvalidationLayer);
     for (LayoutObject* child = slowFirstChild(); child; child = child->nextSibling()) {
         if (!child->hasLayer() || !toLayoutBoxModelObject(child)->layer()->isSelfPaintingLayer())
             child->invalidatePaintIncludingNonSelfPaintingLayerDescendants(paintInvalidationContainer);
     }
 }
@@ skipping 59 matching lines @@
         const blink::LayoutObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showLayoutTreeAndMark(object1, "*", object2, "-", 0);
     } else {
         fprintf(stderr, "Cannot showLayoutTree. Root is (nil)\n");
     }
 }
 
 #endif