Issue repaints for RenderLayers that get new composited backings after

Source/core/rendering/compositing/RenderLayerCompositor.cpp

 /*
  * Copyright (C) 2009, 2010 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 349 matching lines @@
     CompositingPropertyUpdater::UpdateType compositingPropertyUpdateType = CompositingPropertyUpdater::DoNotForceUpdate;
 
     // FIXME: Teach non-style compositing updates how to do partial tree walks.
     if (updateType >= CompositingUpdateAfterLayout) {
         graphicsLayerUpdateType = GraphicsLayerUpdater::ForceUpdate;
         compositingPropertyUpdateType = CompositingPropertyUpdater::ForceUpdate;
     }
 
     RenderLayer* updateRoot = rootRenderLayer();
 
+    Vector<RenderLayer*> layersNeedingRepaint;
+
     if (updateType >= CompositingUpdateAfterCompositingInputChange) {
         bool layersChanged = false;
-
         {
             TRACE_EVENT0("blink_rendering", "CompositingPropertyUpdater::updateAncestorDependentProperties");
             CompositingPropertyUpdater(updateRoot).updateAncestorDependentProperties(updateRoot, compositingPropertyUpdateType);
 #if ASSERT_ENABLED
             CompositingPropertyUpdater::assertNeedsToUpdateAncestorDependantPropertiesBitsCleared(updateRoot);
 #endif
         }
 
         CompositingRequirementsUpdater(m_renderView, m_compositingReasonFinder).update(updateRoot);
 
         {
             TRACE_EVENT0("blink_rendering", "CompositingLayerAssigner::assign");
-            CompositingLayerAssigner(this).assign(updateRoot, layersChanged);
+            CompositingLayerAssigner(this).assign(updateRoot, layersChanged, layersNeedingRepaint);
         }
 
         {
             TRACE_EVENT0("blink_rendering", "RenderLayerCompositor::updateAfterCompositingChange");
             const FrameView::ScrollableAreaSet* scrollableAreas = m_renderView.frameView()->scrollableAreas();
             if (scrollableAreas) {
                 for (FrameView::ScrollableAreaSet::iterator it = scrollableAreas->begin(); it != scrollableAreas->end(); ++it)
                     (*it)->updateAfterCompositingChange();
             }
         }
@@ skipping 38 matching lines @@
         m_needsUpdateFixedBackground = false;
     }
 
     ASSERT(updateRoot || !compositingLayersNeedRebuild());
 
     // The scrolling coordinator may realize that it needs updating while compositing was being updated in this function.
     needsToUpdateScrollingCoordinator |= scrollingCoordinator() && scrollingCoordinator()->needsToUpdateAfterCompositingChange();
     if (needsToUpdateScrollingCoordinator && m_renderView.frame()->isMainFrame() && scrollingCoordinator() && inCompositingMode())
         scrollingCoordinator()->updateAfterCompositingChange();
 
+    for (unsigned i = 0; i < layersNeedingRepaint.size(); i++) {
+        RenderLayer* layer = layersNeedingRepaint[i];
+        layer->repainter().computeRepaintRectsIncludingDescendants();
+
+        repaintOnCompositingChange(layer);
+    }
+
     // Inform the inspector that the layer tree has changed.
     if (m_renderView.frame()->isMainFrame())
         InspectorInstrumentation::layerTreeDidChange(m_renderView.frame());
 }
 
 bool RenderLayerCompositor::allocateOrClearCompositedLayerMapping(RenderLayer* layer, const CompositingStateTransitionType compositedLayerUpdate)
 {
     bool compositedLayerMappingChanged = false;
     bool nonCompositedReasonChanged = updateLayerIfViewportConstrained(layer);
 
@@ skipping 22 matching lines @@
         // If we need to repaint, do so before allocating the compositedLayerMapping
         repaintOnCompositingChange(layer);
         layer->ensureCompositedLayerMapping();
         compositedLayerMappingChanged = true;
 
         // At this time, the ScrollingCooridnator only supports the top-level frame.
         if (layer->isRootLayer() && m_renderView.frame()->isMainFrame()) {
             if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
                 scrollingCoordinator->frameViewRootLayerDidChange(m_renderView.frameView());
         }
-
-        // FIXME: it seems premature to compute this before all compositing state has been updated?
-        // This layer and all of its descendants have cached repaints rects that are relative to
-        // the repaint container, so change when compositing changes; we need to update them here.
-        if (layer->parent())
-            layer->repainter().computeRepaintRectsIncludingDescendants();
-
         break;
     case RemoveOwnCompositedLayerMapping:
     // PutInSquashingLayer means you might have to remove the composited layer mapping first.
     case PutInSquashingLayer:
         if (layer->hasCompositedLayerMapping()) {
             // If we're removing the compositedLayerMapping from a reflection, clear the source GraphicsLayer's pointer to
             // its replica GraphicsLayer. In practice this should never happen because reflectee and reflection
             // are both either composited, or not composited.
             if (layer->isReflection()) {
                 RenderLayer* sourceLayer = toRenderLayerModelObject(layer->renderer()->parent())->layer();
                 if (sourceLayer->hasCompositedLayerMapping()) {
                     ASSERT(sourceLayer->compositedLayerMapping()->mainGraphicsLayer()->replicaLayer() == layer->compositedLayerMapping()->mainGraphicsLayer());
                     sourceLayer->compositedLayerMapping()->mainGraphicsLayer()->setReplicatedByLayer(0);
                 }
             }
 
             layer->clearCompositedLayerMapping();
             compositedLayerMappingChanged = true;
-
-            // This layer and all of its descendants have cached repaints rects that are relative to
-            // the repaint container, so change when compositing changes; we need to update them here.
-            layer->repainter().computeRepaintRectsIncludingDescendants();
-
-            // If we need to repaint, do so now that we've removed the compositedLayerMapping
-            repaintOnCompositingChange(layer);
         }
 
         break;
     case RemoveFromSquashingLayer:
     case NoCompositingStateChange:
         // Do nothing.
         break;
     }
 
     if (layer->hasCompositedLayerMapping() && layer->compositedLayerMapping()->updateRequiresOwnBackingStoreForIntrinsicReasons())
@@ skipping 855 matching lines @@
     } else if (graphicsLayer == m_scrollLayer.get()) {
         name = "LocalFrame Scrolling Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace WebCore