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

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 184 matching lines @@
     if (changeType == CanvasChanged)
         compositor()->setNeedsCompositingUpdate(CompositingUpdateAfterCompositingInputChange);
 
     if (changeType == CanvasContextChanged) {
         compositor()->setNeedsCompositingUpdate(CompositingUpdateAfterCompositingInputChange);
 
         // Although we're missing test coverage, we need to call
         // GraphicsLayer::setContentsToPlatformLayer with the new platform
         // layer for this canvas.
         // See http://crbug.com/349195
-        if (hasCompositedLayerMapping())
-            compositedLayerMapping()->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateSubtree);
+        if (m_compositedLayerMapping)
+            m_compositedLayerMapping->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateSubtree);
     }
 
     if (m_compositedLayerMapping)
         m_compositedLayerMapping->contentChanged(changeType);
 }
 
 bool RenderLayer::paintsWithFilters() const
 {
     if (!renderer()->hasFilter())
         return false;
@@ skipping 825 matching lines @@
     m_compositingReasons = (reasons & mask) | (compositingReasons() & ~mask);
 }
 
 void RenderLayer::setHasCompositingDescendant(bool hasCompositingDescendant)
 {
     if (m_hasCompositingDescendant == static_cast<unsigned>(hasCompositingDescendant))
         return;
 
     m_hasCompositingDescendant = hasCompositingDescendant;
 
-    if (hasCompositedLayerMapping())
-        compositedLayerMapping()->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateLocal);
+    if (m_compositedLayerMapping)
+        m_compositedLayerMapping->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateLocal);
 }
 
 void RenderLayer::setShouldIsolateCompositedDescendants(bool shouldIsolateCompositedDescendants)
 {
     if (m_shouldIsolateCompositedDescendants == static_cast<unsigned>(shouldIsolateCompositedDescendants))
         return;
 
     m_shouldIsolateCompositedDescendants = shouldIsolateCompositedDescendants;
 
-    if (hasCompositedLayerMapping())
-        compositedLayerMapping()->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateLocal);
+    if (m_compositedLayerMapping)
+        m_compositedLayerMapping->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateLocal);
 }
 
 bool RenderLayer::hasAncestorWithFilterOutsets() const
 {
     for (const RenderLayer* curr = this; curr; curr = curr->parent()) {
         RenderLayerModelObject* renderer = curr->renderer();
         if (renderer->style()->hasFilterOutsets())
             return true;
     }
     return false;
@@ skipping 1192 matching lines @@
     return result;
 }
 
 LayoutRect RenderLayer::boundingBoxForCompositingOverlapTest() const
 {
     return overlapBoundsIncludeChildren() ? boundingBoxForCompositing() : fragmentsBoundingBox(this);
 }
 
 static void expandRectForReflectionAndStackingChildren(const RenderLayer* ancestorLayer, RenderLayer::CalculateBoundsOptions options, LayoutRect& result)
 {
-    if (ancestorLayer->reflectionInfo() && !ancestorLayer->reflectionInfo()->reflectionLayer()->hasCompositedLayerMapping())
+    if (ancestorLayer->reflectionInfo() && !ancestorLayer->reflectionInfo()->reflectionLayer()->compositedLayerMapping())
         result.unite(ancestorLayer->reflectionInfo()->reflectionLayer()->boundingBoxForCompositing(ancestorLayer));
 
     ASSERT(ancestorLayer->stackingNode()->isStackingContext() || !ancestorLayer->stackingNode()->hasPositiveZOrderList());
 
 #if ENABLE(ASSERT)
     LayerListMutationDetector mutationChecker(const_cast<RenderLayer*>(ancestorLayer)->stackingNode());
 #endif
 
     RenderLayerStackingNodeIterator iterator(*ancestorLayer->stackingNode(), AllChildren);
     while (RenderLayerStackingNode* node = iterator.next()) {
@@ skipping 48 matching lines @@
         LayoutPoint origin;
         result = physicalBoundingBox(ancestorLayer, &origin);
 
         const_cast<RenderLayer*>(this)->stackingNode()->updateLayerListsIfNeeded();
 
         // Reflections are implemented with RenderLayers that hang off of the reflected layer. However,
         // the reflection layer subtree does not include the subtree of the parent RenderLayer, so
         // a recursive computation of stacking children yields no results. This breaks cases when there are stacking
         // children of the parent, that need to be included in reflected composited bounds.
         // Fix this by including composited bounds of stacking children of the reflected RenderLayer.
-        if (hasCompositedLayerMapping() && parent() && parent()->reflectionInfo() && parent()->reflectionInfo()->reflectionLayer() == this)
+        if (compositedLayerMapping() && parent() && parent()->reflectionInfo() && parent()->reflectionInfo()->reflectionLayer() == this)
             expandRectForReflectionAndStackingChildren(parent(), options, result);
         else
             expandRectForReflectionAndStackingChildren(this, options, result);
 
         // FIXME: We can optimize the size of the composited layers, by not enlarging
         // filtered areas with the outsets if we know that the filter is going to render in hardware.
         // https://bugs.webkit.org/show_bug.cgi?id=81239
         m_renderer->style()->filterOutsets().expandRect(result);
     }
 
@@ skipping 482 matching lines @@
     }
 }
 
 void showLayerTree(const blink::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif