Set relayoutChildren to 'true' only if size change happens in Table

Source/core/rendering/compositing/CompositingLayerAssigner.cpp

 /*
  * Copyright (C) 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2014 Google 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
@@ skipping 40 matching lines @@
 void CompositingLayerAssigner::assign(RenderLayer* updateRoot, Vector<RenderLayer*>& layersNeedingPaintInvalidation)
 {
     TRACE_EVENT0("blink", "CompositingLayerAssigner::assign");
 
     SquashingState squashingState;
     assignLayersToBackingsInternal(updateRoot, squashingState, layersNeedingPaintInvalidation);
     if (squashingState.hasMostRecentMapping)
         squashingState.mostRecentMapping->finishAccumulatingSquashingLayers(squashingState.nextSquashedLayerIndex);
 }
 
-void CompositingLayerAssigner::SquashingState::updateSquashingStateForNewMapping(CompositedLayerMapping* newCompositedLayerMapping, bool hasNewCompositedLayerMapping)
+void CompositingLayerAssigner::SquashingState::updateSquashingStateForNewMapping(CompositedLayerMapping* newCompositedLayerMapping)
 {
     // The most recent backing is done accumulating any more squashing layers.
     if (hasMostRecentMapping)
         mostRecentMapping->finishAccumulatingSquashingLayers(nextSquashedLayerIndex);
 
     nextSquashedLayerIndex = 0;
     boundingRect = IntRect();
     mostRecentMapping = newCompositedLayerMapping;
-    hasMostRecentMapping = hasNewCompositedLayerMapping;
+    hasMostRecentMapping = newCompositedLayerMapping;
     haveAssignedBackingsToEntireSquashingLayerSubtree = false;
 }
 
 bool CompositingLayerAssigner::squashingWouldExceedSparsityTolerance(const RenderLayer* candidate, const CompositingLayerAssigner::SquashingState& squashingState)
 {
     IntRect bounds = candidate->clippedAbsoluteBoundingBox();
     IntRect newBoundingRect = squashingState.boundingRect;
     newBoundingRect.unite(bounds);
     const uint64_t newBoundingRectArea = newBoundingRect.size().area();
     const uint64_t newSquashedArea = squashingState.totalAreaOfSquashedRects + bounds.size().area();
     return newBoundingRectArea > gSquashingSparsityTolerance * newSquashedArea;
 }
 
 bool CompositingLayerAssigner::needsOwnBacking(const RenderLayer* layer) const
 {
     if (!m_compositor->canBeComposited(layer))
         return false;
 
     // If squashing is disabled, then layers that would have been squashed should just be separately composited.
     bool needsOwnBackingForDisabledSquashing = !m_layerSquashingEnabled && requiresSquashing(layer->compositingReasons());
 
     return requiresCompositing(layer->compositingReasons()) || needsOwnBackingForDisabledSquashing || (m_compositor->staleInCompositingMode() && layer->isRootLayer());
 }
 
 CompositingStateTransitionType CompositingLayerAssigner::computeCompositedLayerUpdate(RenderLayer* layer)
 {
     CompositingStateTransitionType update = NoCompositingStateChange;
+    CompositedLayerMapping* compositedLayerMapping = layer->compositedLayerMapping();
     if (needsOwnBacking(layer)) {
-        if (!layer->hasCompositedLayerMapping()) {
+        if (!compositedLayerMapping) {
             update = AllocateOwnCompositedLayerMapping;
         }
     } else {
-        if (layer->hasCompositedLayerMapping())
+        if (compositedLayerMapping)
             update = RemoveOwnCompositedLayerMapping;
 
         if (m_layerSquashingEnabled) {
             if (!layer->subtreeIsInvisible() && requiresSquashing(layer->compositingReasons())) {
                 // We can't compute at this time whether the squashing layer update is a no-op,
                 // since that requires walking the render layer tree.
                 update = PutInSquashingLayer;
             } else if (layer->groupedMapping() || layer->lostGroupedMapping()) {
                 update = RemoveFromSquashingLayer;
             }
@@ skipping 63 matching lines @@
 
 void CompositingLayerAssigner::updateSquashingAssignment(RenderLayer* layer, SquashingState& squashingState, const CompositingStateTransitionType compositedLayerUpdate,
     Vector<RenderLayer*>& layersNeedingPaintInvalidation)
 {
     // NOTE: In the future as we generalize this, the background of this layer may need to be assigned to a different backing than
     // the squashed RenderLayer's own primary contents. This would happen when we have a composited negative z-index element that needs
     // to paint on top of the background, but below the layer's main contents. For now, because we always composite layers
     // when they have a composited negative z-index child, such layers will never need squashing so it is not yet an issue.
     if (compositedLayerUpdate == PutInSquashingLayer) {
         // A layer that is squashed with other layers cannot have its own CompositedLayerMapping.
-        ASSERT(!layer->hasCompositedLayerMapping());
+        ASSERT(!layer->compositedLayerMapping());
         ASSERT(squashingState.hasMostRecentMapping);
 
         bool changedSquashingLayer =
             squashingState.mostRecentMapping->updateSquashingLayerAssignment(layer, squashingState.mostRecentMapping->owningLayer(), squashingState.nextSquashedLayerIndex);
         if (!changedSquashingLayer)
             return;
 
         // If we've modified the collection of squashed layers, we must update
         // the graphics layer geometry.
         squashingState.mostRecentMapping->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateSubtree);
@@ skipping 26 matching lines @@
     CompositingStateTransitionType compositedLayerUpdate = computeCompositedLayerUpdate(reflectionLayer);
     if (compositedLayerUpdate != NoCompositingStateChange) {
         TRACE_LAYER_INVALIDATION(reflectionLayer, InspectorLayerInvalidationTrackingEvent::ReflectionLayerChanged);
         layersNeedingPaintInvalidation.append(reflectionLayer);
         m_layersChanged = true;
         m_compositor->allocateOrClearCompositedLayerMapping(reflectionLayer, compositedLayerUpdate);
     }
     m_compositor->updateDirectCompositingReasons(reflectionLayer);
 
     // FIXME: Why do we updateGraphicsLayerConfiguration here instead of in the GraphicsLayerUpdater?
-    if (reflectionLayer->hasCompositedLayerMapping())
-        reflectionLayer->compositedLayerMapping()->updateGraphicsLayerConfiguration();
+    if (CompositedLayerMapping* compositedLayerMapping = reflectionLayer->compositedLayerMapping())
+        compositedLayerMapping->updateGraphicsLayerConfiguration();
 }
 
 void CompositingLayerAssigner::assignLayersToBackingsInternal(RenderLayer* layer, SquashingState& squashingState, Vector<RenderLayer*>& layersNeedingPaintInvalidation)
 {
     if (m_layerSquashingEnabled && requiresSquashing(layer->compositingReasons())) {
         CompositingReasons reasonsPreventingSquashing = getReasonsPreventingSquashing(layer, squashingState);
         if (reasonsPreventingSquashing)
             layer->setCompositingReasons(layer->compositingReasons() | reasonsPreventingSquashing);
     }
 
@@ skipping 25 matching lines @@
     if (layer->stackingNode()->isStackingContext()) {
         RenderLayerStackingNodeIterator iterator(*layer->stackingNode(), NegativeZOrderChildren);
         while (RenderLayerStackingNode* curNode = iterator.next())
             assignLayersToBackingsInternal(curNode->layer(), squashingState, layersNeedingPaintInvalidation);
     }
 
     if (m_layerSquashingEnabled) {
         // At this point, if the layer is to be separately composited, then its backing becomes the most recent in paint-order.
         if (layer->compositingState() == PaintsIntoOwnBacking) {
             ASSERT(!requiresSquashing(layer->compositingReasons()));
-            squashingState.updateSquashingStateForNewMapping(layer->compositedLayerMapping(), layer->hasCompositedLayerMapping());
+            squashingState.updateSquashingStateForNewMapping(layer->compositedLayerMapping());
         }
     }
 
     if (layer->scrollParent())
         layer->scrollParent()->scrollableArea()->setTopmostScrollChild(layer);
 
     if (layer->needsCompositedScrolling())
         layer->scrollableArea()->setTopmostScrollChild(0);
 
     RenderLayerStackingNodeIterator iterator(*layer->stackingNode(), NormalFlowChildren | PositiveZOrderChildren);
     while (RenderLayerStackingNode* curNode = iterator.next())
         assignLayersToBackingsInternal(curNode->layer(), squashingState, layersNeedingPaintInvalidation);
 
     if (squashingState.hasMostRecentMapping && &squashingState.mostRecentMapping->owningLayer() == layer)
         squashingState.haveAssignedBackingsToEntireSquashingLayerSubtree = true;
 }
 
 }