Move RenderLayer repainting to repaint-after-layout framework.

Source/core/rendering/RenderLayer.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 47 matching lines @@
 #include "core/frame/Settings.h"
 #include "core/html/HTMLFrameElement.h"
 #include "core/page/Page.h"
 #include "core/page/scrolling/ScrollingCoordinator.h"
 #include "core/rendering/ColumnInfo.h"
 #include "core/rendering/CompositedLayerMapping.h"
 #include "core/rendering/FilterEffectRenderer.h"
 #include "core/rendering/HitTestRequest.h"
 #include "core/rendering/HitTestResult.h"
 #include "core/rendering/HitTestingTransformState.h"
+#include "core/rendering/LayoutRectRecorder.h"
 #include "core/rendering/RenderFlowThread.h"
 #include "core/rendering/RenderGeometryMap.h"
 #include "core/rendering/RenderInline.h"
 #include "core/rendering/RenderLayerCompositor.h"
 #include "core/rendering/RenderReplica.h"
 #include "core/rendering/RenderScrollbar.h"
 #include "core/rendering/RenderScrollbarPart.h"
 #include "core/rendering/RenderTreeAsText.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/svg/ReferenceFilterBuilder.h"
@@ skipping 385 matching lines @@
     if (this != view->layer())
         geometryMap.pushMappingsToAncestor(parent(), 0);
 
     // FIXME: why is it OK to not check the ancestors of this layer in order to
     // initialize the HasSeenViewportConstrainedAncestor and HasSeenAncestorWithOverflowClip flags?
     updateLayerPositionsAfterScroll(&geometryMap, IsOverflowScroll);
 }
 
 void RenderLayer::updateLayerPositionsAfterScroll(RenderGeometryMap* geometryMap, UpdateLayerPositionsAfterScrollFlags flags)
 {
+    LayoutRectRecorder recorder(*m_renderer);

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

This seems too heavy handed (but we could leave with a FIXME while we figure out
what to do).

Very few elements move during a scroll (fixed positioned and sticky position are
the one I can think of).

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

It's possible this isn't needed at all. I've been putting in extra calls in
order to see if it's missing rect storage that's causing my under painting. Will
mark with a FIXME to remove if possible.

+
     // FIXME: This shouldn't be needed, but there are some corner cases where
     // these flags are still dirty. Update so that the check below is valid.
     updateDescendantDependentFlags();
 
     // If we have no visible content and no visible descendants, there is no point recomputing
     // our rectangles as they will be empty. If our visibility changes, we are expected to
     // recompute all our positions anyway.
     if (subtreeIsInvisible())
         return;
 
@@ skipping 222 matching lines @@
     }
 }
 
 void RenderLayer::setHasVisibleContent()
 {
     if (m_hasVisibleContent && !m_visibleContentStatusDirty) {
         ASSERT(!parent() || parent()->hasVisibleDescendant());
         return;
     }
 
+    LayoutRectRecorder recorder(*m_renderer);

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

I wouldn't expect changing visible content (mostly position: visible) to cause
some position change.

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

So, the reason I did this here is because I'm currently mimicking when the
current layer code would get the repaint rect. I wanted to make sure that I
wasn't missing anything. Once I've got the bugs worked out we can experiment
with removing some of these LayoutRectRecorder calls and see if anything breaks.
 Just trying to minimize the number of differnces between my changes and the old
system in order to track down the under-painting.

     m_visibleContentStatusDirty = false;
     m_hasVisibleContent = true;
     repainter().computeRepaintRects(renderer()->containerForRepaint());
     if (!m_stackingNode->isNormalFlowOnly()) {
         // We don't collect invisible layers in z-order lists if we are not in compositing mode.
         // As we became visible, we need to dirty our stacking containers ancestors to be properly
         // collected. FIXME: When compositing, we could skip this dirtying phase.
         for (RenderLayerStackingNode* sc = m_stackingNode->ancestorStackingContainerNode(); sc; sc = sc->ancestorStackingContainerNode()) {
             sc->dirtyZOrderLists();
             if (sc->layer()->hasVisibleContent())
@@ skipping 724 matching lines @@
     // The reflection layer should not be moved to the parent.
     if (m_reflectionInfo)
         removeChild(m_reflectionInfo->reflectionLayer());
 
     // Now walk our kids and reattach them to our parent.
     RenderLayer* current = m_first;
     while (current) {
         RenderLayer* next = current->nextSibling();
         removeChild(current);
         m_parent->addChild(current, nextSib);
-        current->repainter().setRepaintStatus(NeedsFullRepaint);
+        if (RuntimeEnabledFeatures::repaintAfterLayoutEnabled())
+            current->renderer()->setShouldDoFullRepaintAfterLayout(true);
+        else
+            current->repainter().setRepaintStatus(NeedsFullRepaint);
         current->updateLayerPositions(0); // FIXME: use geometry map.
         current = next;
     }
 
     // Remove us from the parent.
     m_parent->removeChild(this);
     m_renderer->destroyLayer();
 }
 
 void RenderLayer::insertOnlyThisLayer()
@@ skipping 2545 matching lines @@
     }
 }
 
 void showLayerTree(const WebCore::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif