Remove cached bounds in RenderLayer.

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 96 matching lines @@
     , m_hasSelfPaintingLayerDescendant(false)
     , m_hasSelfPaintingLayerDescendantDirty(false)
     , m_isRootLayer(renderer->isRenderView())
     , m_usedTransparency(false)
     , m_visibleContentStatusDirty(true)
     , m_hasVisibleContent(false)
     , m_visibleDescendantStatusDirty(false)
     , m_hasVisibleDescendant(false)
     , m_hasVisibleNonLayerContent(false)
     , m_isPaginated(false)
-#if ENABLE(ASSERT)
-    , m_needsPositionUpdate(true)
-#endif
     , m_3DTransformedDescendantStatusDirty(true)
     , m_has3DTransformedDescendant(false)
     , m_containsDirtyOverlayScrollbars(false)
     , m_hasFilterInfo(false)
     , m_needsAncestorDependentCompositingInputsUpdate(true)
     , m_needsDescendantDependentCompositingInputsUpdate(true)
     , m_childNeedsCompositingInputsUpdate(true)
     , m_hasCompositingDescendant(false)
     , m_hasNonCompositedChild(false)
     , m_shouldIsolateCompositedDescendants(false)
@@ skipping 127 matching lines @@
         // FIXME: Remove incremental compositing updates after fixing the chicken/egg issues
         // https://code.google.com/p/chromium/issues/detail?id=343756
         DisableCompositingQueryAsserts disabler;
         bool needsPaginationUpdate = isPaginated() || enclosingPaginationLayer();
         updatePaginationRecursive(needsPaginationUpdate);
     }
 }
 
 void RenderLayer::updateLayerPositionRecursive()
 {
-    updateLayerPosition();
-
     if (hasOverflowControls()) {
         // FIXME: We should figure out the right time to position the overflow controls.
         // This call appears to be necessary to pass some layout test that use EventSender,
         // presumably because the normal time to position the controls is during paint. We
         // probably shouldn't position the overflow controls during paint either...
         DisableCompositingQueryAsserts disabler;
         scrollableArea()->positionOverflowControls(IntSize());
     }
 
     if (m_reflectionInfo)
@@ skipping 37 matching lines @@
     return renderer()->style()->position() == FixedPosition && renderer()->containingBlock()->enclosingLayer()->isRootLayer();
 }
 
 bool RenderLayer::scrollsWithRespectTo(const RenderLayer* other) const
 {
     if (scrollsWithViewport() != other->scrollsWithViewport())
         return true;
     return ancestorScrollingLayer() != other->ancestorScrollingLayer();
 }
 
-void RenderLayer::updateLayerPositionsAfterOverflowScroll()
-{
-    m_clipper.clearClipRectsIncludingDescendants();
-    updateLayerPositionsAfterScrollRecursive();
-}
-
-void RenderLayer::updateLayerPositionsAfterScrollRecursive()
-{
-    if (updateLayerPosition())
-        m_renderer->setPreviousPaintInvalidationRect(m_renderer->boundsRectForPaintInvalidation(m_renderer->containerForPaintInvalidation()));
-
-    for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
-        child->updateLayerPositionsAfterScrollRecursive();
-}
-
 void RenderLayer::updateTransformationMatrix()
 {
     if (m_transform) {
         RenderBox* box = renderBox();
         ASSERT(box);
         m_transform->makeIdentity();
         box->style()->applyTransform(*m_transform, box->pixelSnappedBorderBoxRect().size(), RenderStyle::IncludeTransformOrigin);
         makeMatrixRenderable(*m_transform, compositor()->hasAcceleratedCompositing());
     }
 }
@@ skipping 439 matching lines @@
     }
 
     // If we live in a 3d hierarchy, then the layer at the root of that hierarchy needs
     // the m_has3DTransformedDescendant set.
     if (preserves3D())
         return has3DTransform() || m_has3DTransformedDescendant;
 
     return has3DTransform();
 }
 
-bool RenderLayer::updateLayerPosition()
+const IntSize RenderLayer::size() const

[abarth-chromium, 2014/08/07 21:51:12]

No need for |const| here.  IntSize is a value type.

[skobes, 2014/08/07 22:21:09]

Done.

+{
+    if (renderer()->isInline() && renderer()->isRenderInline())
+        return toRenderInline(renderer())->linesBoundingBox().size();
+
+    // FIXME: Is snapping the size really needed here?
+    if (RenderBox* box = renderBox())
+        return pixelSnappedIntSize(box->size(), box->location());
+
+    return IntSize();
+}
+
+const LayoutPoint RenderLayer::location() const

[abarth-chromium, 2014/08/07 21:51:12]

No need for |const| here.  LayoutPoint is a value type.

[skobes, 2014/08/07 22:21:09]

Done.

 {
     LayoutPoint localPoint;
     LayoutSize inlineBoundingBoxOffset; // We don't put this into the RenderLayer x/y for inlines, so we need to subtract it out when done.
 
     if (renderer()->isInline() && renderer()->isRenderInline()) {
         RenderInline* inlineFlow = toRenderInline(renderer());
         IntRect lineBox = inlineFlow->linesBoundingBox();
-        m_size = lineBox.size();
         inlineBoundingBoxOffset = toSize(lineBox.location());
         localPoint += inlineBoundingBoxOffset;
     } else if (RenderBox* box = renderBox()) {
-        // FIXME: Is snapping the size really needed here for the RenderBox case?
-        m_size = pixelSnappedIntSize(box->size(), box->location());
         localPoint += box->topLeftLocationOffset();
     }
 
     if (!renderer()->isOutOfFlowPositioned() && renderer()->parent()) {
         // We must adjust our position by walking up the render tree looking for the
         // nearest enclosing object with a layer.
         RenderObject* curr = renderer()->parent();
         while (curr && !curr->hasLayer()) {
             if (curr->isBox() && !curr->isTableRow()) {
                 // Rows and cells share the same coordinate space (that of the section).
@@ skipping 36 matching lines @@
             else
                 localPoint += parent()->renderer()->columnOffset(localPoint);
         }
 
         if (parent()->renderer()->hasOverflowClip()) {
             IntSize scrollOffset = parent()->renderBox()->scrolledContentOffset();
             localPoint -= scrollOffset;
         }
     }
 
-    bool positionOrOffsetChanged = false;
-    if (renderer()->isRelPositioned()) {
-        LayoutSize newOffset = toRenderBoxModelObject(renderer())->offsetForInFlowPosition();
-        positionOrOffsetChanged = newOffset != m_offsetForInFlowPosition;
-        m_offsetForInFlowPosition = newOffset;
-        localPoint.move(m_offsetForInFlowPosition);
-    } else {
-        m_offsetForInFlowPosition = LayoutSize();
-    }
+    localPoint.move(offsetForInFlowPosition());
 
     // FIXME: We'd really like to just get rid of the concept of a layer rectangle and rely on the renderers.
     localPoint -= inlineBoundingBoxOffset;
 
-    if (m_location != localPoint)
-        positionOrOffsetChanged = true;
-    m_location = localPoint;
+    return localPoint;
+}
 
-#if ENABLE(ASSERT)
-    m_needsPositionUpdate = false;
-#endif
-    return positionOrOffsetChanged;
+const LayoutSize RenderLayer::offsetForInFlowPosition() const
+{
+    return renderer()->isRelPositioned() ? toRenderBoxModelObject(renderer())->offsetForInFlowPosition() : LayoutSize();
 }
 
 TransformationMatrix RenderLayer::perspectiveTransform() const
 {
     if (!renderer()->hasTransform())
         return TransformationMatrix();
 
     RenderStyle* style = renderer()->style();
     if (!style->hasPerspective())
         return TransformationMatrix();
@@ skipping 2857 matching lines @@
     }
 }
 
 void showLayerTree(const blink::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif