Move RenderLayer repainting to repaint-after-layout framework.

Source/core/rendering/RenderLayerRepainter.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 28 matching lines @@
  * other provisions required by the MPL or the GPL, as the case may be.
  * If you do not delete the provisions above, a recipient may use your
  * version of this file under any of the LGPL, the MPL or the GPL.
  */
 
 #include "config.h"
 #include "core/rendering/RenderLayerRepainter.h"
 
 #include "core/rendering/CompositedLayerMapping.h"
 #include "core/rendering/FilterEffectRenderer.h"
+#include "core/rendering/LayoutRectRecorder.h"
 #include "core/rendering/RenderLayer.h"
 #include "core/rendering/RenderView.h"
 
 namespace WebCore {
 
 RenderLayerRepainter::RenderLayerRepainter(RenderLayerModelObject* renderer)
     : m_renderer(renderer)
     , m_repaintStatus(NeedsNormalRepaint)
 {
 }
 
 void RenderLayerRepainter::repaintAfterLayout(RenderGeometryMap* geometryMap, bool shouldCheckForRepaint)
 {
+    if (RuntimeEnabledFeatures::repaintAfterLayoutEnabled())
+        return;
+
     // FIXME: really, we're in the repaint phase here, and the following queries are legal.
     // Until those states are fully fledged, I'll just disable the ASSERTS.
     DisableCompositingQueryAsserts disabler;
     if (m_renderer->layer()->hasVisibleContent()) {
         RenderView* view = m_renderer->view();
         ASSERT(view);
         // FIXME: LayoutState does not work with RenderLayers as there is not a 1-to-1
         // mapping between them and the RenderObjects. It would be neat to enable
         // LayoutState outside the layout() phase and use it here.
         ASSERT(!view->layoutStateEnabled());
@@ skipping 27 matching lines @@
 void RenderLayerRepainter::clearRepaintRects()
 {
     ASSERT(!m_renderer->layer()->hasVisibleContent());
 
     m_repaintRect = IntRect();
     m_outlineBox = IntRect();
 }
 
 void RenderLayerRepainter::computeRepaintRects(const RenderLayerModelObject* repaintContainer, const RenderGeometryMap* geometryMap)
 {
+    if (RuntimeEnabledFeatures::repaintAfterLayoutEnabled())

[Julien - ping for review, 2014/02/14 18:05:48]

My naive view is that this code shouldn't run at all if RAL is enabled.

[dsinclair, 2014/02/14 18:15:27]

When you say this code, do you mean anything in this file, or this method
specifically?

For this call specifically, I figured it was easier to early return then wrap
all callers in a if (!RuntimeEnabledFeature::repaintAfterLayoutEnabled())

+        return;
+
     m_repaintRect = m_renderer->clippedOverflowRectForRepaint(repaintContainer);
     m_outlineBox = m_renderer->outlineBoundsForRepaint(repaintContainer, geometryMap);
 }
 
 void RenderLayerRepainter::computeRepaintRectsIncludingDescendants()
 {
-    // FIXME: computeRepaintRects() has to walk up the parent chain for every layer to compute the rects.
-    // We should make this more efficient.
-    // FIXME: it's wrong to call this when layout is not up-to-date, which we do.
-    computeRepaintRects(m_renderer->containerForRepaint());
+    if (RuntimeEnabledFeatures::repaintAfterLayoutEnabled()) {
+        // This is a little silly as we create and immediately destroy the RAII
+        // object but it makes sure we correctly set all of the repaint flags.
+        LayoutRectRecorder recorder(*m_renderer);

[Julien - ping for review, 2014/02/14 18:05:48]

Won't this force m_oldRepaintRect == m_newRepaintRect as no layout happened in
the meantime?

[dsinclair, 2014/02/14 18:15:27]

Possibly? If we've already updated oldRepaintRect we won't touch with this call.
At most, we could change the newRepaintRect.

If layout didn't happen, then this would end up setting the two rects to be the
same, but then they should, basically, get dropped in repaintAfterLayoutIfNeeded
because the rects are the same and we haven't set to force a full repaint.

+
+    } else {
+        // FIXME: computeRepaintRects() has to walk up the parent chain for every layer to compute the rects.
+        // We should make this more efficient.
+        // FIXME: it's wrong to call this when layout is not up-to-date, which we do.
+        computeRepaintRects(m_renderer->containerForRepaint());
+    }
 
     for (RenderLayer* layer = m_renderer->layer()->firstChild(); layer; layer = layer->nextSibling())
         layer->repainter().computeRepaintRectsIncludingDescendants();
 }
 
 inline bool RenderLayerRepainter::shouldRepaintAfterLayout() const
 {
+    if (RuntimeEnabledFeatures::repaintAfterLayoutEnabled())
+        return false;
+
     if (m_repaintStatus == NeedsNormalRepaint)
         return true;
 
     // Composited layers that were moved during a positioned movement only
     // layout, don't need to be repainted. They just need to be recomposited.
     ASSERT(m_repaintStatus == NeedsFullRepaintForPositionedMovementLayout);
     return m_renderer->compositingState() != PaintsIntoOwnBacking;
 }
 
 // Since we're only painting non-composited layers, we know that they all share the same repaintContainer.
 void RenderLayerRepainter::repaintIncludingNonCompositingDescendants(RenderLayerModelObject* repaintContainer)
 {
     m_renderer->repaintUsingContainer(repaintContainer, pixelSnappedIntRect(m_renderer->clippedOverflowRectForRepaint(repaintContainer)));
 
     for (RenderLayer* curr = m_renderer->layer()->firstChild(); curr; curr = curr->nextSibling()) {
         if (!curr->hasCompositedLayerMapping())
             curr->repainter().repaintIncludingNonCompositingDescendants(repaintContainer);
     }
 }
 
 LayoutRect RenderLayerRepainter::repaintRectIncludingNonCompositingDescendants() const
 {
-    LayoutRect repaintRect = m_repaintRect;
+    LayoutRect repaintRect;
+    if (RuntimeEnabledFeatures::repaintAfterLayoutEnabled())
+        repaintRect = m_renderer->newRepaintRect();
+    else
+        repaintRect = m_repaintRect;
+
     for (RenderLayer* child = m_renderer->layer()->firstChild(); child; child = child->nextSibling()) {
         // Don't include repaint rects for composited child layers; they will paint themselves and have a different origin.
         if (child->hasCompositedLayerMapping())
             continue;
 
         repaintRect.unite(child->repainter().repaintRectIncludingNonCompositingDescendants());
     }
     return repaintRect;
 }
 
@@ skipping 95 matching lines @@
 RenderLayer* RenderLayerRepainter::enclosingFilterRepaintLayer() const
 {
     for (const RenderLayer* curr = m_renderer->layer(); curr; curr = curr->parent()) {
         if ((curr != m_renderer->layer() && curr->requiresFullLayerImageForFilters()) || curr->compositingState() == PaintsIntoOwnBacking || curr->isRootLayer())
             return const_cast<RenderLayer*>(curr);
     }
     return 0;
 }
 
 } // Namespace WebCore