Update should paint flag when a float's composited scrolling status changes

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

Index: third_party/WebKit/Source/core/layout/LayoutBlockFlow.cpp
diff --git a/third_party/WebKit/Source/core/layout/LayoutBlockFlow.cpp b/third_party/WebKit/Source/core/layout/LayoutBlockFlow.cpp
index 491f7a8af2b8332511ba74428a2479dfd93a63ed..7bbf27772b2e925d360db15201f076e19027db1d 100644
--- a/third_party/WebKit/Source/core/layout/LayoutBlockFlow.cpp
+++ b/third_party/WebKit/Source/core/layout/LayoutBlockFlow.cpp
@@ -2045,7 +2045,7 @@ void LayoutBlockFlow::invalidatePaintForOverhangingFloats(bool paintAllDescendan
         // Only issue paint invaldiations for the object if it is overhanging, is not in its own layer, and
         // is our responsibility to paint (m_shouldPaint is set). When paintAllDescendants is true, the latter
         // condition is replaced with being a descendant of us.
-        if (logicalBottomForFloat(floatingObject) > logicalHeight()
+        if (isOverhangingFloat(floatingObject)
             && !floatingObject.layoutObject()->hasSelfPaintingLayer()
             && (floatingObject.shouldPaint() || (paintAllDescendants && floatingObject.layoutObject()->isDescendantOf(this)))) {
 
@@ -2461,7 +2461,7 @@ bool LayoutBlockFlow::hasOverhangingFloat(LayoutBox* layoutBox)
     if (it == floatingObjectSet.end())
         return false;
 
-    return logicalBottomForFloat(*it->get()) > logicalHeight();
+    return isOverhangingFloat(**it);
 }
 
 void LayoutBlockFlow::addIntrudingFloats(LayoutBlockFlow* prev, LayoutUnit logicalLeftOffset, LayoutUnit logicalTopOffset)
@@ -2628,6 +2628,34 @@ LayoutUnit LayoutBlockFlow::logicalRightFloatOffsetForLine(LayoutUnit logicalTop
     return fixedOffset;
 }
 
+void LayoutBlockFlow::setAncestorShouldPaintFloatingObject(const LayoutBox& floatBox, bool shouldPaint)
+{
+    ASSERT(floatBox.isFloating());
+    ASSERT(!floatBox.hasSelfPaintingLayer());
+    for (LayoutObject* ancestor = floatBox.parent(); ancestor && ancestor->isLayoutBlockFlow(); ancestor = ancestor->parent()) {
+        LayoutBlockFlow* ancestorBlock = toLayoutBlockFlow(ancestor);
+        FloatingObjects* ancestorFloatingObjects = ancestorBlock->m_floatingObjects.get();
+        if (!ancestorFloatingObjects)
+            break;
+        FloatingObjectSet::iterator it = ancestorFloatingObjects->set().find<FloatingObjectHashTranslator>(const_cast<LayoutBox*>(&floatBox));
+        if (it == ancestorFloatingObjects->set().end())
+            break;
+        FloatingObject& floatingObject = **it;
+        if (shouldPaint) {
+            ASSERT(!floatingObject.shouldPaint());
+            if (ancestorBlock->hasSelfPaintingLayer() || !ancestorBlock->isOverhangingFloat(floatingObject) || ancestorBlock->createsNewFormattingContext()) {

[chrishtr, 2016/02/02 19:32:04]

Why is this the right set of conditions? Does this occur elsewhere? (Share
code?)

[Xianzhu, 2016/02/02 20:19:07]

The conditions are scattered in this file, mainly in layoutBlockFlow(),
addLowestFloatFromChildren(), addOverhaningFloats(), etc. Different places use
different combinations of the conditions because of their different contexts in
which some conditions are already checked or not applicable.

Basically the rules of float painting are:
- Let the nearest enclosing block in which the float doesn't overhang paint the
float;
- Or even if the float overhangs, if the block has self-painting layer, the
block paints the float.

Checked the conditions again and found that createNewFormattingContext() is not
necessary because a float never overhangs a block creating new formatting
context (the block's height has been adjusted to include full height of the
float).

trchen@ discussed with me about float painting. His idea is to allocate
self-painting layers for floats, so that they always paint themselves and we can
avoid the complex logics dealing with shouldPaint flags. His method can also
avoid wrong paint-ordering of overlapping floats because of negative margins.
This method seems to also apply to all other pseudo stacking contexts. I think
it is worth trying the method in the future.

+                floatingObject.setShouldPaint(true);
+                return;
+            }
+        } else if (floatingObject.shouldPaint()) {
+            floatingObject.setShouldPaint(false);
+            return;
+        }
+    }
+    // We should have found the ancestor to update shouldPaint flag.
+    ASSERT_NOT_REACHED();
+}
+
 IntRect alignSelectionRectToDevicePixels(LayoutRect& rect)
 {
     LayoutUnit roundedX = LayoutUnit(rect.x().round());