Move RenderLayer repainting to repaint-after-layout framework.

Source/core/rendering/RenderObject.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 958 matching lines @@
     RespectImageOrientationEnum shouldRespectImageOrientation() const;
 
     bool isRelayoutBoundaryForInspector() const;
 
     const LayoutRect& newRepaintRect() const { return m_newRepaintRect; }
     void setNewRepaintRect(const LayoutRect& rect) { m_newRepaintRect = rect; }
 
     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 shouldDoFullRepaintIfSelfPaintingLayer() const { return m_bitfields.shouldDoFullRepaintIfSelfPaintingLayer(); }
+    void setShouldDoFullRepaintIfSelfPaintingLayer(bool b) { m_bitfields.setShouldDoFullRepaintIfSelfPaintingLayer(b); }
+
+    bool shouldDoFullRepaintIfNotComposited() const { return m_bitfields.shouldDoFullRepaintIfNotComposited(); }
+    void setShouldDoFullRepaintIfNotComposited(bool b) { m_bitfields.setShouldDoFullRepaintIfNotComposited(b); }
+
     bool shouldRepaintOverflowIfNeeded() const { return m_bitfields.shouldRepaintOverflowIfNeeded(); }
 
-    void clearRepaintRects()
-    {
-        setNewRepaintRect(LayoutRect());
-        setOldRepaintRect(LayoutRect());
-
-        setShouldDoFullRepaintAfterLayout(false);
-        setShouldRepaintOverflowIfNeeded(false);
-        setLayoutDidGetCalled(false);
-    }
+    void clearRepaintState();
 
     // layoutDidGetCalled indicates whether this render object was re-laid-out
     // since the last call to setLayoutDidGetCalled(false) on this object.
     bool layoutDidGetCalled() { return m_bitfields.layoutDidGetCalled(); }
     void setLayoutDidGetCalled(bool b) { m_bitfields.setLayoutDidGetCalled(b); }
 
     bool shouldDisableLayoutState() const { return hasColumns() || hasTransform() || hasReflection() || style()->isFlippedBlocksWritingMode(); }
 
 protected:
     inline bool layerCreationAllowedForSubtree() const;
@@ skipping 97 matching lines @@
         };
 
     public:
         RenderObjectBitfields(Node* node)
             : m_selfNeedsLayout(false)
             // FIXME: shouldDoFullRepaintAfterLayout is needed because we reset
             // the layout bits before repaint when doing repaintAfterLayout.
             // 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)
             , m_posChildNeedsLayout(false)
             , m_needsSimplifiedNormalFlowLayout(false)
             , m_preferredLogicalWidthsDirty(false)
             , m_floating(false)
             , m_isAnonymous(!node)
             , m_isText(false)
             , m_isBox(false)
@@ skipping 12 matching lines @@
             , m_hasColumns(false)
             , m_layoutDidGetCalled(false)
             , m_positionedState(IsStaticallyPositioned)
             , m_selectionState(SelectionNone)
             , m_flowThreadState(NotInsideFlowThread)
             , m_boxDecorationState(NoBoxDecorations)
             , m_hasPendingResourceUpdate(false)
         {
         }
 
-        // 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);
         ADD_BOOLEAN_BITFIELD(posChildNeedsLayout, PosChildNeedsLayout);
         ADD_BOOLEAN_BITFIELD(needsSimplifiedNormalFlowLayout, NeedsSimplifiedNormalFlowLayout);
         ADD_BOOLEAN_BITFIELD(preferredLogicalWidthsDirty, PreferredLogicalWidthsDirty);
         ADD_BOOLEAN_BITFIELD(floating, Floating);
 
         ADD_BOOLEAN_BITFIELD(isAnonymous, IsAnonymous);
         ADD_BOOLEAN_BITFIELD(isText, IsText);
@@ skipping 272 matching lines @@
 void showTree(const WebCore::RenderObject*);
 void showLineTree(const WebCore::RenderObject*);
 void showRenderTree(const WebCore::RenderObject* object1);
 // We don't make object2 an optional parameter so that showRenderTree
 // can be called from gdb easily.
 void showRenderTree(const WebCore::RenderObject* object1, const WebCore::RenderObject* object2);
 
 #endif
 
 #endif // RenderObject_h