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

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 241 matching lines @@
 #endif
 
 void RenderLayerCompositor::applyOverlayFullscreenVideoAdjustment()
 {
     m_inOverlayFullscreenVideo = false;
     if (!m_rootContentLayer)
         return;
 
     bool isLocalRoot = m_renderView.frame()->isLocalRoot();
     RenderVideo* video = findFullscreenVideoRenderer(m_renderView.document());
-    if (!video || !video->layer()->hasCompositedLayerMapping()) {
+    CompositedLayerMapping* videoCompositedLayerMapping = nullptr;
+
+    if (video)
+        videoCompositedLayerMapping = video->layer()->compositedLayerMapping();
+
+    if (!videoCompositedLayerMapping) {
         if (isLocalRoot) {
             GraphicsLayer* backgroundLayer = fixedRootBackgroundLayer();
             if (backgroundLayer && !backgroundLayer->parent())
                 rootFixedBackgroundsChanged();
         }
         return;
     }
 
-    GraphicsLayer* videoLayer = video->layer()->compositedLayerMapping()->mainGraphicsLayer();
+    GraphicsLayer* videoLayer = videoCompositedLayerMapping->mainGraphicsLayer();
 
     // The fullscreen video has layer position equal to its enclosing frame's scroll position because fullscreen container is fixed-positioned.
     // We should reset layer position here since we are going to reattach the layer at the very top level.
     videoLayer->setPosition(IntPoint());
 
     // Only steal fullscreen video layer and clear all other layers if we are the main frame.
     if (!isLocalRoot)
         return;
 
     m_rootContentLayer->removeAllChildren();
@@ skipping 121 matching lines @@
 
 bool RenderLayerCompositor::allocateOrClearCompositedLayerMapping(RenderLayer* layer, const CompositingStateTransitionType compositedLayerUpdate)
 {
     bool compositedLayerMappingChanged = false;
 
     // FIXME: It would be nice to directly use the layer's compositing reason,
     // but allocateOrClearCompositedLayerMapping also gets called without having updated compositing
     // requirements fully.
     switch (compositedLayerUpdate) {
     case AllocateOwnCompositedLayerMapping:
-        ASSERT(!layer->hasCompositedLayerMapping());
+        ASSERT(!layer->compositedLayerMapping());
         setCompositingModeEnabled(true);
 
         // If we need to issue paint invalidations, do so before allocating the compositedLayerMapping and clearing out the groupedMapping.
         paintInvalidationOnCompositingChange(layer);
 
         // If this layer was previously squashed, we need to remove its reference to a groupedMapping right away, so
         // that computing paint invalidation rects will know the layer's correct compositingState.
         // FIXME: do we need to also remove the layer from it's location in the squashing list of its groupedMapping?
         // Need to create a test where a squashed layer pops into compositing. And also to cover all other
         // sorts of compositingState transitions.
         layer->setLostGroupedMapping(false);
         layer->setGroupedMapping(0);
 
         layer->ensureCompositedLayerMapping();
         compositedLayerMappingChanged = true;
 
         // At this time, the ScrollingCooridnator only supports the top-level frame.
         if (layer->isRootLayer() && m_renderView.frame()->isLocalRoot()) {
             if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
                 scrollingCoordinator->frameViewRootLayerDidChange(m_renderView.frameView());
         }
         break;
     case RemoveOwnCompositedLayerMapping:
     // PutInSquashingLayer means you might have to remove the composited layer mapping first.
     case PutInSquashingLayer:
-        if (layer->hasCompositedLayerMapping()) {
+        if (layer->compositedLayerMapping()) {
             // 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);
+                if (CompositedLayerMapping* sourceCompositedLayerMapping = sourceLayer->compositedLayerMapping()) {
+                    ASSERT(sourceCompositedLayerMapping->mainGraphicsLayer()->replicaLayer() == layer->compositedLayerMapping()->mainGraphicsLayer());
+                    sourceCompositedLayerMapping->mainGraphicsLayer()->setReplicatedByLayer(0);
                 }
             }
 
             layer->clearCompositedLayerMapping();
             compositedLayerMappingChanged = true;
         }
 
         break;
     case RemoveFromSquashingLayer:
     case NoCompositingStateChange:
@@ skipping 161 matching lines @@
     return 0;
 }
 
 // FIXME: What does this function do? It needs a clearer name.
 bool RenderLayerCompositor::parentFrameContentLayers(RenderPart* renderer)
 {
     RenderLayerCompositor* innerCompositor = frameContentsCompositor(renderer);
     if (!innerCompositor || !innerCompositor->staleInCompositingMode() || innerCompositor->rootLayerAttachment() != RootLayerAttachedViaEnclosingFrame)
         return false;
 
-    RenderLayer* layer = renderer->layer();
-    if (!layer->hasCompositedLayerMapping())
+    CompositedLayerMapping* compositedLayerMapping = renderer->layer()->compositedLayerMapping();
+    if (!compositedLayerMapping)
         return false;
 
-    CompositedLayerMapping* compositedLayerMapping = layer->compositedLayerMapping();
     GraphicsLayer* hostingLayer = compositedLayerMapping->parentForSublayers();
     GraphicsLayer* rootLayer = innerCompositor->rootGraphicsLayer();
     if (hostingLayer->children().size() != 1 || hostingLayer->children()[0] != rootLayer) {
         hostingLayer->removeAllChildren();
         hostingLayer->addChild(rootLayer);
     }
     return true;
 }
 
 static void fullyInvalidatePaintRecursive(RenderLayer* layer)
@@ skipping 544 matching lines @@
     } else if (graphicsLayer == m_scrollLayer.get()) {
         name = "LocalFrame Scrolling Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink