Move RenderLayer repainting to repaint-after-layout framework.

Source/core/rendering/RenderObject.h

Index: Source/core/rendering/RenderObject.h
diff --git a/Source/core/rendering/RenderObject.h b/Source/core/rendering/RenderObject.h
index 29efffa7cdcd14912dfe459f0561d24425fd2ab2..c484f09e2074d5af0a6db9acdaf2f9fe36990766 100644
--- a/Source/core/rendering/RenderObject.h
+++ b/Source/core/rendering/RenderObject.h
@@ -976,19 +976,24 @@ public:
     const LayoutRect& oldRepaintRect() const { return m_oldRepaintRect; }
     void setOldRepaintRect(const LayoutRect& rect) { m_oldRepaintRect = rect; }
 
+    LayoutRect newOutlineRect();
+    void setNewOutlineRect(const LayoutRect&);
+
+    LayoutRect oldOutlineRect();
+    void setOldOutlineRect(const LayoutRect&);
+
     bool shouldDoFullRepaintAfterLayout() const { return m_bitfields.shouldDoFullRepaintAfterLayout(); }
     void setShouldDoFullRepaintAfterLayout(bool b) { m_bitfields.setShouldDoFullRepaintAfterLayout(b); }
-    bool shouldRepaintOverflowIfNeeded() const { return m_bitfields.shouldRepaintOverflowIfNeeded(); }
 
-    void clearRepaintRects()
-    {
-        setNewRepaintRect(LayoutRect());
-        setOldRepaintRect(LayoutRect());
+    bool shouldDoFullRepaintIfSelfPaintingLayer() const { return m_bitfields.shouldDoFullRepaintIfSelfPaintingLayer(); }
+    void setShouldDoFullRepaintIfSelfPaintingLayer(bool b) { m_bitfields.setShouldDoFullRepaintIfSelfPaintingLayer(b); }
 
-        setShouldDoFullRepaintAfterLayout(false);
-        setShouldRepaintOverflowIfNeeded(false);
-        setLayoutDidGetCalled(false);
-    }
+    bool shouldDoFullRepaintIfNotComposited() const { return m_bitfields.shouldDoFullRepaintIfNotComposited(); }
+    void setShouldDoFullRepaintIfNotComposited(bool b) { m_bitfields.setShouldDoFullRepaintIfNotComposited(b); }
+
+    bool shouldRepaintOverflowIfNeeded() const { return m_bitfields.shouldRepaintOverflowIfNeeded(); }
+
+    void clearRepaintState();
 
     // layoutDidGetCalled indicates whether this render object was re-laid-out
     // since the last call to setLayoutDidGetCalled(false) on this object.
@@ -1106,6 +1111,8 @@ private:
             // Holding the layout bits until after repaint would remove the need
             // for this flag.
             , m_shouldDoFullRepaintAfterLayout(false)
+            , m_shouldDoFullRepaintIfSelfPaintingLayer(false)
+            , m_shouldDoFullRepaintIfNotComposited(false)

[Julien - ping for review, 2014/03/07 18:26:38]

The second boolean is not needed if we clear the needsLayout flags during
repaintTree (this is possible while keeping our no-renderer-needs-layout assert
as we now track whether we actually called layout on any renderer).

Adding more reference to self-painting layer is a bad smell in some code that is
RenderLayer agnostic so there is something we should be doing that we don't. I
expect it has to do with positioned elements that we need to relayout but don't
in this case.

[dsinclair, 2014/03/07 19:29:48]

I'm not sure if  m_shouldDoFullRepaintIfNotComposited can go away. It's the
replacement for the RenderLayerRepainter shouldRepaintAfterLayout check. In
RenderObject::setLayerNeedsFullRepaintForPositionedMovementLayout() I need to
know if this is a composited layer but I can't ask there as we're called from
setStyle so I need to delay the check until after style is done and this flag
lets me do it.
Ah, so you think it's either covered, or should be handled similar to
https://codereview.chromium.org/187813004/. Once that's landed I'll try removing
this and see if there is a better solution.

[Julien - ping for review, 2014/03/13 22:26:50]

I wasn't too stressed out about this one. It would be just better if we just
kept the needsPositionedMovementOnly boolean across layout and used that to make
the invalidation decision. We will need to keep track of our layout bits anyway
to skip certain invalidation so this would be going into the right direction.
I thought that there would be a way to make this work by detecting overflow
change and relaying out the appropriate renderers. It turns out that this would
yield to a lot of over-repainting or we would need to check isSelfPaintingLayer.

The back-story is that we don't track the visual overflow for self-painting
layer. That's the reason for this boolean to exist. We should fix our visual
overflow but we shouldn't gate RAL on that.

             , m_shouldRepaintOverflowIfNeeded(false)
             , m_needsPositionedMovementLayout(false)
             , m_normalChildNeedsLayout(false)
@@ -1138,9 +1145,11 @@ private:
         {
         }
 
-        // 32 bits have been used in the first word, and 3 in the second.
+        // 32 bits have been used in the first word, and 5 in the second.
         ADD_BOOLEAN_BITFIELD(selfNeedsLayout, SelfNeedsLayout);
         ADD_BOOLEAN_BITFIELD(shouldDoFullRepaintAfterLayout, ShouldDoFullRepaintAfterLayout);
+        ADD_BOOLEAN_BITFIELD(shouldDoFullRepaintIfSelfPaintingLayer, ShouldDoFullRepaintIfSelfPaintingLayer);
+        ADD_BOOLEAN_BITFIELD(shouldDoFullRepaintIfNotComposited, ShouldDoFullRepaintIfNotComposited);
         ADD_BOOLEAN_BITFIELD(shouldRepaintOverflowIfNeeded, ShouldRepaintOverflowIfNeeded);
         ADD_BOOLEAN_BITFIELD(needsPositionedMovementLayout, NeedsPositionedMovementLayout);
         ADD_BOOLEAN_BITFIELD(normalChildNeedsLayout, NormalChildNeedsLayout);