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

Source/core/rendering/compositing/CompositedLayerMapping.cpp

 /*
  * Copyright (C) 2009, 2010, 2011 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 359 matching lines @@
 
 bool CompositedLayerMapping::updateGraphicsLayerConfiguration()
 {
     ASSERT(m_owningLayer.compositor()->lifecycle().state() == DocumentLifecycle::InCompositingUpdate);
 
     // Note carefully: here we assume that the compositing state of all descendants have been updated already,
     // so it is legitimate to compute and cache the composited bounds for this layer.
     updateCompositedBounds();
 
     if (RenderLayerReflectionInfo* reflection = m_owningLayer.reflectionInfo()) {
-        if (reflection->reflectionLayer()->hasCompositedLayerMapping())
-            reflection->reflectionLayer()->compositedLayerMapping()->updateCompositedBounds();
+        if (CompositedLayerMapping* compositedLayerMapping = reflection->reflectionLayer()->compositedLayerMapping())
+            compositedLayerMapping->updateCompositedBounds();
     }
 
     RenderLayerCompositor* compositor = this->compositor();
     RenderObject* renderer = this->renderer();
 
     bool layerConfigChanged = false;
     setBackgroundLayerPaintsFixedRootBackground(compositor->needsFixedRootBackgroundLayer(&m_owningLayer));
 
     // The background layer is currently only used for fixed root backgrounds.
     if (updateBackgroundLayer(m_backgroundLayerPaintsFixedRootBackground))
@@ skipping 79 matching lines @@
             m_graphicsLayer->setMaskLayer(m_childClippingMaskLayer.get());
         else if (hasClippingLayer())
             clippingLayer()->setMaskLayer(m_childClippingMaskLayer.get());
         else if (hasScrollingLayer())
             scrollingLayer()->setMaskLayer(m_childClippingMaskLayer.get());
         else if (isAcceleratedContents(renderer))
             m_graphicsLayer->setContentsClippingMaskLayer(m_childClippingMaskLayer.get());
     }
 
     if (m_owningLayer.reflectionInfo()) {
-        if (m_owningLayer.reflectionInfo()->reflectionLayer()->hasCompositedLayerMapping()) {
-            GraphicsLayer* reflectionLayer = m_owningLayer.reflectionInfo()->reflectionLayer()->compositedLayerMapping()->mainGraphicsLayer();
+        if (CompositedLayerMapping* compositedLayerMapping = m_owningLayer.reflectionInfo()->reflectionLayer()->compositedLayerMapping()) {
+            GraphicsLayer* reflectionLayer = compositedLayerMapping->mainGraphicsLayer();
             m_graphicsLayer->setReplicatedByLayer(reflectionLayer);
         }
     } else {
         m_graphicsLayer->setReplicatedByLayer(0);
     }
 
     updateBackgroundColor();
 
     if (renderer->isImage()) {
         if (isDirectlyCompositedImage()) {
@@ skipping 154 matching lines @@
     // Set opacity, if it is not animating.
     if (!renderer()->style()->isRunningOpacityAnimationOnCompositor())
         updateOpacity(renderer()->style());
 
     if (!renderer()->style()->isRunningFilterAnimationOnCompositor())
         updateFilters(renderer()->style());
 
     // We compute everything relative to the enclosing compositing layer.
     IntRect ancestorCompositingBounds;
     if (compositingContainer) {
-        ASSERT(compositingContainer->hasCompositedLayerMapping());
-        ancestorCompositingBounds = compositingContainer->compositedLayerMapping()->pixelSnappedCompositedBounds();
+        CompositedLayerMapping* compositedLayerMapping = compositingContainer->compositedLayerMapping();
+        ASSERT(compositedLayerMapping);
+        ancestorCompositingBounds = compositedLayerMapping->pixelSnappedCompositedBounds();
     }
 
     IntRect localCompositingBounds;
     IntRect relativeCompositingBounds;
     LayoutPoint offsetFromCompositedAncestor;
     IntPoint snappedOffsetFromCompositedAncestor;
     computeBoundsOfOwningLayer(compositingContainer, localCompositingBounds, relativeCompositingBounds, offsetFromCompositedAncestor, snappedOffsetFromCompositedAncestor);
 
     IntPoint graphicsLayerParentLocation;
     computeGraphicsLayerParentLocation(compositingContainer, ancestorCompositingBounds, graphicsLayerParentLocation);
@@ skipping 201 matching lines @@
         FloatPoint3D compositedTransformOrigin(
             relativeCompositingBounds.width() * 0.5f,
             relativeCompositingBounds.height() * 0.5f,
             0.f);
         m_graphicsLayer->setTransformOrigin(compositedTransformOrigin);
     }
 }
 
 void CompositedLayerMapping::updateReflectionLayerGeometry(Vector<RenderLayer*>& layersNeedingPaintInvalidation)
 {
-    if (!m_owningLayer.reflectionInfo() || !m_owningLayer.reflectionInfo()->reflectionLayer()->hasCompositedLayerMapping())
+    if (!m_owningLayer.reflectionInfo())
         return;
 
     CompositedLayerMapping* reflectionCompositedLayerMapping = m_owningLayer.reflectionInfo()->reflectionLayer()->compositedLayerMapping();
+    if (!reflectionCompositedLayerMapping)
+        return;
+
     reflectionCompositedLayerMapping->updateGraphicsLayerGeometry(&m_owningLayer, &m_owningLayer, layersNeedingPaintInvalidation);
 }
 
 void CompositedLayerMapping::updateScrollingLayerGeometry(const IntRect& localCompositingBounds)
 {
     if (!m_scrollingLayer)
         return;
 
     ASSERT(m_scrollingContentsLayer);
     RenderBox* renderBox = toRenderBox(renderer());
@@ skipping 853 matching lines @@
     // FIXME: We shouldn't be called with a stale z-order lists. See bug 85512.
     parent->stackingNode()->updateLayerListsIfNeeded();
 
 #if ENABLE(ASSERT)
     LayerListMutationDetector mutationChecker(parent->stackingNode());
 #endif
 
     RenderLayerStackingNodeIterator normalFlowIterator(*parent->stackingNode(), AllChildren);
     while (RenderLayerStackingNode* curNode = normalFlowIterator.next()) {
         RenderLayer* curLayer = curNode->layer();
-        if (curLayer->hasCompositedLayerMapping())
+        if (curLayer->compositedLayerMapping())
             continue;
         if (curLayer->hasVisibleContent() || hasVisibleNonCompositingDescendant(curLayer))
             return true;
     }
 
     return false;
 }
 
 bool CompositedLayerMapping::containsPaintedContent() const
 {
@@ skipping 556 matching lines @@
     } else if (graphicsLayer == m_scrollingBlockSelectionLayer.get()) {
         name = "Scrolling Block Selection Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink