Move rendering/RenderBox to layout/LayoutBox.

Source/core/layout/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 52 matching lines @@
 #include "platform/graphics/paint/ClipDisplayItem.h"
 #include "platform/graphics/paint/DisplayItemList.h"
 #include "platform/graphics/paint/TransformDisplayItem.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
-static IntRect clipBox(RenderBox* renderer);
+static IntRect clipBox(LayoutBox* renderer);
 
 static IntRect contentsRect(const LayoutObject* renderer)
 {
     if (!renderer->isBox())
         return IntRect();
 
     return renderer->isVideo() ?
         toLayoutVideo(renderer)->videoBox() :
-        pixelSnappedIntRect(toRenderBox(renderer)->contentBoxRect());
+        pixelSnappedIntRect(toLayoutBox(renderer)->contentBoxRect());
 }
 
 static IntRect backgroundRect(const LayoutObject* renderer)
 {
     if (!renderer->isBox())
         return IntRect();
 
     LayoutRect rect;
-    const RenderBox* box = toRenderBox(renderer);
+    const LayoutBox* box = toLayoutBox(renderer);
     EFillBox clip = box->style()->backgroundClip();
     switch (clip) {
     case BorderFillBox:
         rect = box->borderBoxRect();
         break;
     case PaddingFillBox:
         rect = box->paddingBoxRect();
         break;
     case ContentFillBox:
         rect = box->contentBoxRect();
@@ skipping 162 matching lines @@
 {
     m_graphicsLayer->setOpacity(compositingOpacity(style.opacity()));
 }
 
 void CompositedLayerMapping::updateTransform(const LayoutStyle& style)
 {
     // FIXME: This could use m_owningLayer.transform(), but that currently has transform-origin
     // baked into it, and we don't want that.
     TransformationMatrix t;
     if (m_owningLayer.hasTransformRelatedProperty()) {
-        style.applyTransform(t, LayoutSize(toRenderBox(renderer())->pixelSnappedSize()), LayoutStyle::ExcludeTransformOrigin);
+        style.applyTransform(t, LayoutSize(toLayoutBox(renderer())->pixelSnappedSize()), LayoutStyle::ExcludeTransformOrigin);
         makeMatrixRenderable(t, compositor()->hasAcceleratedCompositing());
     }
 
     m_graphicsLayer->setTransform(t);
 }
 
 void CompositedLayerMapping::updateFilters(const LayoutStyle& style)
 {
     m_graphicsLayer->setFilters(owningLayer().computeFilterOperations(style));
 }
@@ skipping 253 matching lines @@
         layerConfigChanged = LayerCompositor::parentFrameContentLayers(toLayoutPart(renderer));
 
     // Changes to either the internal hierarchy or the mask layer have an impact
     // on painting phases, so we need to update when either are updated.
     if (layerConfigChanged || maskLayerChanged)
         updatePaintingPhases();
 
     return layerConfigChanged;
 }
 
-static IntRect clipBox(RenderBox* renderer)
+static IntRect clipBox(LayoutBox* renderer)
 {
     LayoutRect result = LayoutRect::infiniteIntRect();
     if (renderer->hasOverflowClip())
         result = renderer->overflowClipRect(LayoutPoint());
 
     if (renderer->hasClip())
         result.intersect(renderer->clipRect(LayoutPoint()));
 
     return pixelSnappedIntRect(result);
 }
@@ skipping 136 matching lines @@
 
     FloatSize contentsSize = relativeCompositingBounds.size();
 
     updateMainGraphicsLayerGeometry(relativeCompositingBounds, localCompositingBounds, graphicsLayerParentLocation);
     updateContentsOffsetInCompositingLayer(snappedOffsetFromCompositedAncestor, graphicsLayerParentLocation);
     updateSquashingLayerGeometry(offsetFromCompositedAncestor, graphicsLayerParentLocation, m_owningLayer, m_squashedLayers, m_squashingLayer.get(), &m_squashingLayerOffsetFromTransformedAncestor, layersNeedingPaintInvalidation);
 
     // If we have a layer that clips children, position it.
     IntRect clippingBox;
     if (m_childContainmentLayer)
-        clippingBox = clipBox(toRenderBox(renderer()));
+        clippingBox = clipBox(toLayoutBox(renderer()));
 
     updateChildContainmentLayerGeometry(clippingBox, localCompositingBounds);
     updateChildTransformLayerGeometry();
 
     updateMaskLayerGeometry();
     updateTransformGeometry(snappedOffsetFromCompositedAncestor, relativeCompositingBounds);
     updateForegroundLayerGeometry(contentsSize, clippingBox);
     updateBackgroundLayerGeometry(contentsSize);
     updateReflectionLayerGeometry(layersNeedingPaintInvalidation);
     updateScrollingLayerGeometry(localCompositingBounds);
@@ skipping 45 matching lines @@
     m_graphicsLayer->setContentsVisible(contentsVisible);
 
     m_graphicsLayer->setBackfaceVisibility(renderer()->style()->backfaceVisibility() == BackfaceVisibilityVisible);
 }
 
 void CompositedLayerMapping::computeGraphicsLayerParentLocation(const Layer* compositingContainer, const IntRect& ancestorCompositingBounds, IntPoint& graphicsLayerParentLocation)
 {
     if (compositingContainer && compositingContainer->compositedLayerMapping()->hasClippingLayer()) {
         // If the compositing ancestor has a layer to clip children, we parent in that, and therefore
         // position relative to it.
-        IntRect clippingBox = clipBox(toRenderBox(compositingContainer->renderer()));
+        IntRect clippingBox = clipBox(toLayoutBox(compositingContainer->renderer()));
         graphicsLayerParentLocation = clippingBox.location() + roundedIntSize(compositingContainer->subpixelAccumulation());
     } else if (compositingContainer && compositingContainer->compositedLayerMapping()->childTransformLayer()) {
         // Similarly, if the compositing ancestor has a child transform layer, we parent in that, and therefore
         // position relative to it. It's already taken into account the contents offset, so we do not need to here.
         graphicsLayerParentLocation = roundedIntPoint(compositingContainer->subpixelAccumulation());
     } else if (compositingContainer) {
         graphicsLayerParentLocation = ancestorCompositingBounds.location();
     } else {
         graphicsLayerParentLocation = renderer()->view()->documentRect().location();
     }
 
     if (compositingContainer && compositingContainer->needsCompositedScrolling()) {
-        RenderBox* renderBox = toRenderBox(compositingContainer->renderer());
-        IntSize scrollOffset = renderBox->scrolledContentOffset();
-        IntPoint scrollOrigin(renderBox->borderLeft(), renderBox->borderTop());
+        LayoutBox* layoutBox = toLayoutBox(compositingContainer->renderer());
+        IntSize scrollOffset = layoutBox->scrolledContentOffset();
+        IntPoint scrollOrigin(layoutBox->borderLeft(), layoutBox->borderTop());
         graphicsLayerParentLocation = scrollOrigin - scrollOffset;
     }
 }
 
 void CompositedLayerMapping::updateAncestorClippingLayerGeometry(const Layer* compositingContainer, const IntPoint& snappedOffsetFromCompositedAncestor, IntPoint& graphicsLayerParentLocation)
 {
     if (!compositingContainer || !m_ancestorClippingLayer)
         return;
 
     ClipRectsContext clipRectsContext(compositingContainer, PaintingClipRectsIgnoringOverflowClip, IgnoreOverlayScrollbarSize);
@@ skipping 49 matching lines @@
         m_childClippingMaskLayer->setPosition(m_childContainmentLayer->position());
         m_childClippingMaskLayer->setSize(m_childContainmentLayer->size());
         m_childClippingMaskLayer->setOffsetFromRenderer(m_childContainmentLayer->offsetFromRenderer());
     }
 }
 
 void CompositedLayerMapping::updateChildTransformLayerGeometry()
 {
     if (!m_childTransformLayer)
         return;
-    const IntRect borderBox = toRenderBox(m_owningLayer.renderer())->pixelSnappedBorderBoxRect();
+    const IntRect borderBox = toLayoutBox(m_owningLayer.renderer())->pixelSnappedBorderBoxRect();
     m_childTransformLayer->setSize(borderBox.size());
     m_childTransformLayer->setPosition(FloatPoint(contentOffsetInCompositingLayer()));
 }
 
 void CompositedLayerMapping::updateMaskLayerGeometry()
 {
     if (!m_maskLayer)
         return;
 
     if (m_maskLayer->size() != m_graphicsLayer->size()) {
         m_maskLayer->setSize(m_graphicsLayer->size());
         m_maskLayer->setNeedsDisplay();
     }
     m_maskLayer->setPosition(FloatPoint());
     m_maskLayer->setOffsetFromRenderer(m_graphicsLayer->offsetFromRenderer());
 }
 
 void CompositedLayerMapping::updateTransformGeometry(const IntPoint& snappedOffsetFromCompositedAncestor, const IntRect& relativeCompositingBounds)
 {
     if (m_owningLayer.hasTransformRelatedProperty()) {
-        const LayoutRect borderBox = toRenderBox(renderer())->borderBoxRect();
+        const LayoutRect borderBox = toLayoutBox(renderer())->borderBoxRect();
 
         // Get layout bounds in the coords of compositingContainer to match relativeCompositingBounds.
         IntRect layerBounds = pixelSnappedIntRect(toLayoutPoint(m_owningLayer.subpixelAccumulation()), borderBox.size());
         layerBounds.moveBy(snappedOffsetFromCompositedAncestor);
 
         // Update properties that depend on layer dimensions
         FloatPoint3D transformOrigin = computeTransformOrigin(IntRect(IntPoint(), layerBounds.size()));
 
         // |transformOrigin| is in the local space of this layer. layerBounds - relativeCompositingBounds converts to the space of the
         // compositing bounds relative to the composited ancestor. This does not apply to the z direction, since the page is 2D.
@@ skipping 19 matching lines @@
     CompositedLayerMapping* reflectionCompositedLayerMapping = m_owningLayer.reflectionInfo()->reflectionLayer()->compositedLayerMapping();
     reflectionCompositedLayerMapping->updateGraphicsLayerGeometry(&m_owningLayer, &m_owningLayer, layersNeedingPaintInvalidation);
 }
 
 void CompositedLayerMapping::updateScrollingLayerGeometry(const IntRect& localCompositingBounds)
 {
     if (!m_scrollingLayer)
         return;
 
     ASSERT(m_scrollingContentsLayer);
-    RenderBox* renderBox = toRenderBox(renderer());
-    IntRect clientBox = enclosingIntRect(renderBox->clientBoxRect());
+    LayoutBox* layoutBox = toLayoutBox(renderer());
+    IntRect clientBox = enclosingIntRect(layoutBox->clientBoxRect());
     DoubleSize adjustedScrollOffset = m_owningLayer.scrollableArea()->adjustedScrollOffset();
     m_scrollingLayer->setPosition(FloatPoint(clientBox.location() - localCompositingBounds.location() + roundedIntSize(m_owningLayer.subpixelAccumulation())));
     m_scrollingLayer->setSize(clientBox.size());
 
     IntSize oldScrollingLayerOffset = m_scrollingLayer->offsetFromRenderer();
     m_scrollingLayer->setOffsetFromRenderer(-toIntSize(clientBox.location()));
 
     if (m_childClippingMaskLayer && !renderer()->style()->clipPath()) {
         m_childClippingMaskLayer->setPosition(m_scrollingLayer->position());
         m_childClippingMaskLayer->setSize(m_scrollingLayer->size());
         m_childClippingMaskLayer->setOffsetFromRenderer(toIntSize(clientBox.location()));
     }
 
     bool clientBoxOffsetChanged = oldScrollingLayerOffset != m_scrollingLayer->offsetFromRenderer();
 
-    IntSize scrollSize(renderBox->scrollWidth(), renderBox->scrollHeight());
+    IntSize scrollSize(layoutBox->scrollWidth(), layoutBox->scrollHeight());
     if (scrollSize != m_scrollingContentsLayer->size() || clientBoxOffsetChanged)
         m_scrollingContentsLayer->setNeedsDisplay();
 
     DoubleSize scrollingContentsOffset(clientBox.location().x() - adjustedScrollOffset.width(), clientBox.location().y() - adjustedScrollOffset.height());
     // The scroll offset change is compared using floating point so that fractional scroll offset
     // change can be propagated to compositor.
     if (scrollingContentsOffset != m_scrollingContentsLayer->offsetDoubleFromRenderer() || scrollSize != m_scrollingContentsLayer->size()) {
         bool coordinatorHandlesOffset = compositor()->scrollingLayerDidChange(&m_owningLayer);
         m_scrollingContentsLayer->setPosition(coordinatorHandlesOffset ? FloatPoint() : FloatPoint(-toFloatSize(adjustedScrollOffset)));
     }
 
     m_scrollingContentsLayer->setSize(scrollSize);
     // FIXME: The paint offset and the scroll offset should really be separate concepts.
     m_scrollingContentsLayer->setOffsetDoubleFromRenderer(scrollingContentsOffset, GraphicsLayer::DontSetNeedsDisplay);
 
     if (m_foregroundLayer) {
         if (m_foregroundLayer->size() != m_scrollingContentsLayer->size())
             m_foregroundLayer->setSize(m_scrollingContentsLayer->size());
         m_foregroundLayer->setNeedsDisplay();
         m_foregroundLayer->setOffsetFromRenderer(m_scrollingContentsLayer->offsetFromRenderer());
     }
 
     updateScrollingBlockSelection();
 }
 
 void CompositedLayerMapping::updateChildClippingMaskLayerGeometry()
 {
     if (!m_childClippingMaskLayer || !renderer()->style()->clipPath())
         return;
-    RenderBox* renderBox = toRenderBox(renderer());
-    IntRect clientBox = enclosingIntRect(renderBox->clientBoxRect());
+    LayoutBox* layoutBox = toLayoutBox(renderer());
+    IntRect clientBox = enclosingIntRect(layoutBox->clientBoxRect());
 
     m_childClippingMaskLayer->setPosition(m_graphicsLayer->position());
     m_childClippingMaskLayer->setSize(m_graphicsLayer->size());
     m_childClippingMaskLayer->setOffsetFromRenderer(toIntSize(clientBox.location()));
 
     // NOTE: also some stuff happening in updateChildContainmentLayerGeometry().
 }
 
 void CompositedLayerMapping::updateForegroundLayerGeometry(const FloatSize& relativeCompositingBoundsSize, const IntRect& clippingBox)
 {
@@ skipping 1380 matching lines @@
     } else if (graphicsLayer == m_scrollingBlockSelectionLayer.get()) {
         name = "Scrolling Block Selection Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink