Move rendering/RenderBox to layout/LayoutBox.

Source/core/layout/Layer.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 314 matching lines @@
     if (updateLayerPosition())
         m_renderer->setPreviousPaintInvalidationRect(m_renderer->boundsRectForPaintInvalidation(m_renderer->containerForPaintInvalidation()));
 
     for (Layer* child = firstChild(); child; child = child->nextSibling())
         child->updateLayerPositionsAfterScrollRecursive();
 }
 
 void Layer::updateTransformationMatrix()
 {
     if (m_transform) {
-        RenderBox* box = renderBox();
+        LayoutBox* box = layoutBox();
         ASSERT(box);
         m_transform->makeIdentity();
         box->style()->applyTransform(*m_transform, LayoutSize(box->pixelSnappedSize()), LayoutStyle::IncludeTransformOrigin);
         makeMatrixRenderable(*m_transform, compositor()->hasAcceleratedCompositing());
     }
 }
 
 void Layer::updateTransform(const LayoutStyle* oldStyle, const LayoutStyle& newStyle)
 {
     if (oldStyle && newStyle.transformDataEquivalent(*oldStyle))
@@ skipping 43 matching lines @@
     return renderingContext;
 }
 
 TransformationMatrix Layer::currentTransform(LayoutStyle::ApplyTransformOrigin applyOrigin) const
 {
     if (!m_transform)
         return TransformationMatrix();
 
     // m_transform includes transform-origin, so we need to recompute the transform here.
     if (applyOrigin == LayoutStyle::ExcludeTransformOrigin) {
-        RenderBox* box = renderBox();
+        LayoutBox* box = layoutBox();
         TransformationMatrix currTransform;
         box->style()->applyTransform(currTransform, LayoutSize(box->pixelSnappedSize()), LayoutStyle::ExcludeTransformOrigin);
         makeMatrixRenderable(currTransform, compositor()->hasAcceleratedCompositing());
         return currTransform;
     }
 
     return *m_transform;
 }
 
 TransformationMatrix Layer::renderableTransform(PaintBehavior paintBehavior) const
 {
     if (!m_transform)
         return TransformationMatrix();
 
     if (paintBehavior & PaintBehaviorFlattenCompositingLayers) {
         TransformationMatrix matrix = *m_transform;
         makeMatrixRenderable(matrix, false /* flatten 3d */);
         return matrix;
     }
 
     return *m_transform;
 }
 
-static bool checkContainingBlockChainForPagination(LayoutBoxModelObject* renderer, RenderBox* ancestorColumnsRenderer)
+static bool checkContainingBlockChainForPagination(LayoutBoxModelObject* renderer, LayoutBox* ancestorColumnsRenderer)
 {
     RenderView* view = renderer->view();
     LayoutBoxModelObject* prevBlock = renderer;
     RenderBlock* containingBlock;
     for (containingBlock = renderer->containingBlock();
         containingBlock && containingBlock != view && containingBlock != ancestorColumnsRenderer;
         containingBlock = containingBlock->containingBlock())
         prevBlock = containingBlock;
 
     // If the columns block wasn't in our containing block chain, then we aren't paginated by it.
@@ skipping 109 matching lines @@
                 return;
             }
         }
         return;
     }
 
     // If we're not normal flow, then we need to look for a multi-column object between us and our stacking container.
     LayerStackingNode* ancestorStackingContextNode = m_stackingNode->ancestorStackingContextNode();
     for (Layer* curr = parent(); curr; curr = curr->parent()) {
         if (curr->renderer()->hasColumns()) {
-            m_isPaginated = checkContainingBlockChainForPagination(renderer(), curr->renderBox());
+            m_isPaginated = checkContainingBlockChainForPagination(renderer(), curr->layoutBox());
             return;
         }
         if (curr->stackingNode() == ancestorStackingContextNode)
             return;
     }
 }
 
 void Layer::clearPaginationRecursive()
 {
     m_enclosingPaginationLayer = 0;
@@ skipping 244 matching lines @@
 {
     LayoutPoint localPoint;
     LayoutPoint inlineBoundingBoxOffset; // We don't put this into the Layer 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 = lineBox.location();
         localPoint.moveBy(inlineBoundingBoxOffset);
-    } else if (RenderBox* box = renderBox()) {
+    } else if (LayoutBox* box = layoutBox()) {
         m_size = pixelSnappedIntSize(box->size(), box->location());
         localPoint.moveBy(box->topLeftLocation());
     }
 
     if (!renderer()->isOutOfFlowPositioned() && !renderer()->isColumnSpanAll() && renderer()->parent()) {
         // We must adjust our position by walking up the render tree looking for the
         // nearest enclosing object with a layer.
         LayoutObject* curr = renderer()->parent();
         while (curr && !curr->hasLayer()) {
             if (curr->isBox() && !curr->isTableRow()) {
                 // Rows and cells share the same coordinate space (that of the section).
                 // Omit them when computing our xpos/ypos.
-                localPoint.moveBy(toRenderBox(curr)->topLeftLocation());
+                localPoint.moveBy(toLayoutBox(curr)->topLeftLocation());
             }
             curr = curr->parent();
         }
         if (curr->isBox() && curr->isTableRow()) {
             // Put ourselves into the row coordinate space.
-            localPoint.moveBy(-toRenderBox(curr)->topLeftLocation());
+            localPoint.moveBy(-toLayoutBox(curr)->topLeftLocation());
         }
     }
 
     // Subtract our parent's scroll offset.
     if (renderer()->isOutOfFlowPositioned() && enclosingPositionedAncestor()) {
         Layer* positionedParent = enclosingPositionedAncestor();
 
         // For positioned layers, we subtract out the enclosing positioned layer's scroll offset.
         if (positionedParent->renderer()->hasOverflowClip()) {
-            IntSize offset = positionedParent->renderBox()->scrolledContentOffset();
+            IntSize offset = positionedParent->layoutBox()->scrolledContentOffset();
             localPoint -= offset;
         }
 
         if (positionedParent->renderer()->isRelPositioned() && positionedParent->renderer()->isRenderInline()) {
-            LayoutSize offset = toRenderInline(positionedParent->renderer())->offsetForInFlowPositionedInline(*toRenderBox(renderer()));
+            LayoutSize offset = toRenderInline(positionedParent->renderer())->offsetForInFlowPositionedInline(*toLayoutBox(renderer()));
             localPoint += offset;
         }
     } else if (parent()) {
         // FIXME: This code is very wrong, but luckily only needed in the old/current multicol
         // implementation. The compositing system doesn't understand columns and we're hacking
         // around that fact by faking the position of the Layers when we think we'll end up
         // being composited.
         if (hasStyleDeterminedDirectCompositingReasons() && !useRegionBasedColumns()) {
             // FIXME: Composited layers ignore pagination, so about the best we can do is make sure they're offset into the appropriate column.
             // They won't split across columns properly.
             if (!parent()->renderer()->hasColumns() && parent()->renderer()->isDocumentElement() && renderer()->view()->hasColumns())
                 localPoint += renderer()->view()->columnOffset(localPoint);
             else
                 localPoint += parent()->renderer()->columnOffset(localPoint);
         }
 
         if (parent()->renderer()->hasOverflowClip()) {
-            IntSize scrollOffset = parent()->renderBox()->scrolledContentOffset();
+            IntSize scrollOffset = parent()->layoutBox()->scrolledContentOffset();
             localPoint -= scrollOffset;
         }
     }
 
     bool positionOrOffsetChanged = false;
     if (renderer()->isRelPositioned()) {
         LayoutSize newOffset = renderer()->offsetForInFlowPosition();
         positionOrOffsetChanged = newOffset != m_offsetForInFlowPosition;
         m_offsetForInFlowPosition = newOffset;
         localPoint.move(m_offsetForInFlowPosition);
@@ skipping 17 matching lines @@
 TransformationMatrix Layer::perspectiveTransform() const
 {
     if (!renderer()->hasTransformRelatedProperty())
         return TransformationMatrix();
 
     const LayoutStyle& style = renderer()->styleRef();
     if (!style.hasPerspective())
         return TransformationMatrix();
 
     // Maybe fetch the perspective from the backing?
-    const IntRect borderBox = toRenderBox(renderer())->pixelSnappedBorderBoxRect();
+    const IntRect borderBox = toLayoutBox(renderer())->pixelSnappedBorderBoxRect();
     const float boxWidth = borderBox.width();
     const float boxHeight = borderBox.height();
 
     float perspectiveOriginX = floatValueForLength(style.perspectiveOriginX(), boxWidth);
     float perspectiveOriginY = floatValueForLength(style.perspectiveOriginY(), boxHeight);
 
     // A perspective origin of 0,0 makes the vanishing point in the center of the element.
     // We want it to be in the top-left, so subtract half the height and width.
     perspectiveOriginX -= boxWidth / 2.0f;
     perspectiveOriginY -= boxHeight / 2.0f;
 
     TransformationMatrix t;
     t.translate(perspectiveOriginX, perspectiveOriginY);
     t.applyPerspective(style.perspective());
     t.translate(-perspectiveOriginX, -perspectiveOriginY);
 
     return t;
 }
 
 FloatPoint Layer::perspectiveOrigin() const
 {
     if (!renderer()->hasTransformRelatedProperty())
         return FloatPoint();
 
-    const LayoutRect borderBox = toRenderBox(renderer())->borderBoxRect();
+    const LayoutRect borderBox = toLayoutBox(renderer())->borderBoxRect();
     const LayoutStyle& style = renderer()->styleRef();
 
     return FloatPoint(floatValueForLength(style.perspectiveOriginX(), borderBox.width().toFloat()), floatValueForLength(style.perspectiveOriginY(), borderBox.height().toFloat()));
 }
 
 static inline bool isFixedPositionedContainer(Layer* layer)
 {
     return layer->isRootLayer() || layer->hasTransformRelatedProperty();
 }
 
@@ skipping 184 matching lines @@
     }
 
     // If we have a reflection, then we need to account for that when we push the clip.  Reflect our entire
     // current transparencyClipBox to catch all child layers.
     // FIXME: Accelerated compositing will eventually want to do something smart here to avoid incorporating this
     // size into the parent layer.
     if (layer->renderer()->hasReflection()) {
         LayoutPoint delta;
         layer->convertToLayerCoords(rootLayer, delta);
         clipRect.move(-delta.x(), -delta.y());
-        clipRect.unite(layer->renderBox()->reflectedRect(clipRect));
+        clipRect.unite(layer->layoutBox()->reflectedRect(clipRect));
         clipRect.moveBy(delta);
     }
 }
 
 LayoutRect Layer::transparencyClipBox(const Layer* layer, const Layer* rootLayer, TransparencyClipBoxBehavior transparencyBehavior,
     TransparencyClipBoxMode transparencyMode, const LayoutSize& subPixelAccumulation, PaintBehavior paintBehavior)
 {
     // FIXME: Although this function completely ignores CSS-imposed clipping, we did already intersect with the
     // paintDirtyRect, and that should cut down on the amount we have to paint.  Still it
     // would be better to respect clips.
@@ skipping 367 matching lines @@
 void Layer::didUpdateNeedsCompositedScrolling()
 {
     updateSelfPaintingLayer();
 }
 
 void Layer::updateReflectionInfo(const LayoutStyle* oldStyle)
 {
     ASSERT(!oldStyle || !renderer()->style()->reflectionDataEquivalent(oldStyle));
     if (renderer()->hasReflection()) {
         if (!m_reflectionInfo)
-            m_reflectionInfo = adoptPtr(new LayerReflectionInfo(*renderBox()));
+            m_reflectionInfo = adoptPtr(new LayerReflectionInfo(*layoutBox()));
         m_reflectionInfo->updateAfterStyleChange(oldStyle);
     } else if (m_reflectionInfo) {
         m_reflectionInfo->destroy();
         m_reflectionInfo = nullptr;
     }
 }
 
 void Layer::updateStackingNode()
 {
     if (requiresStackingNode())
@@ skipping 497 matching lines @@
         newHitTestLocation = HitTestLocation(localPoint);
 
     // Now do a hit test with the root layer shifted to be us.
     return hitTestLayer(this, containerLayer, request, result, localHitTestRect, newHitTestLocation, true, newTransformState.get(), zOffset);
 }
 
 bool Layer::hitTestContents(const HitTestRequest& request, HitTestResult& result, const LayoutRect& layerBounds, const HitTestLocation& hitTestLocation, HitTestFilter hitTestFilter) const
 {
     ASSERT(isSelfPaintingLayer() || hasSelfPaintingLayerDescendant());
 
-    if (!renderer()->hitTest(request, result, hitTestLocation, toLayoutPoint(layerBounds.location() - renderBoxLocation()), hitTestFilter)) {
+    if (!renderer()->hitTest(request, result, hitTestLocation, toLayoutPoint(layerBounds.location() - layoutBoxLocation()), hitTestFilter)) {
         // It's wrong to set innerNode, but then claim that you didn't hit anything, unless it is
         // a rect-based test.
         ASSERT(!result.innerNode() || (request.listBased() && result.listBasedTestResult().size()));
         return false;
     }
 
     // For positioned generated content, we might still not have a
     // node by the time we get to the layer level, since none of
     // the content in the layer has an element. So just walk up
     // the tree.
@@ skipping 47 matching lines @@
 
     return resultLayer;
 }
 
 Layer* Layer::hitTestPaginatedChildLayer(Layer* childLayer, Layer* rootLayer, const HitTestRequest& request, HitTestResult& result,
     const LayoutRect& hitTestRect, const HitTestLocation& hitTestLocation, const HitTestingTransformState* transformState, double* zOffset)
 {
     Vector<Layer*> columnLayers;
     LayerStackingNode* ancestorNode = m_stackingNode->isNormalFlowOnly() ? parent()->stackingNode() : m_stackingNode->ancestorStackingContextNode();
     for (Layer* curr = childLayer->parent(); curr; curr = curr->parent()) {
-        if (curr->renderer()->hasColumns() && checkContainingBlockChainForPagination(childLayer->renderer(), curr->renderBox()))
+        if (curr->renderer()->hasColumns() && checkContainingBlockChainForPagination(childLayer->renderer(), curr->layoutBox()))
             columnLayers.append(curr);
         if (curr->stackingNode() == ancestorNode)
             break;
     }
 
     ASSERT(columnLayers.size());
     return hitTestChildLayerColumns(childLayer, rootLayer, request, result, hitTestRect, hitTestLocation, transformState, zOffset,
         columnLayers, columnLayers.size() - 1);
 }
 
@@ skipping 125 matching lines @@
         // FIXME: We should not allow paint invalidation out of paint invalidation state. crbug.com/457415
         DisablePaintInvalidationStateAsserts disabler;
         child->invalidatePaintForBlockSelectionGaps();
     }
 
     if (m_blockSelectionGapsBounds.isEmpty())
         return;
 
     LayoutRect rect = m_blockSelectionGapsBounds;
     if (renderer()->hasOverflowClip()) {
-        RenderBox* box = renderBox();
+        LayoutBox* box = layoutBox();
         rect.move(-box->scrolledContentOffset());
         if (!scrollableArea()->usesCompositedScrolling())
             rect.intersect(box->overflowClipRect(LayoutPoint()));
     }
     if (renderer()->hasClip())
-        rect.intersect(toRenderBox(renderer())->clipRect(LayoutPoint()));
+        rect.intersect(toLayoutBox(renderer())->clipRect(LayoutPoint()));
     if (!rect.isEmpty()) {
         // FIXME: We should not allow paint invalidation out of paint invalidation state. crbug.com/457415
         DisablePaintInvalidationStateAsserts disabler;
         renderer()->invalidatePaintRectangle(rect);
     }
 }
 
 IntRect Layer::blockSelectionGapsBounds() const
 {
     if (!renderer()->isRenderBlockFlow())
@@ skipping 50 matching lines @@
     // (3) Floats.  When a layer has overhanging floats that it paints, we need to make sure to include these overhanging floats
     // as part of our bounding box.  We do this because we are the responsible layer for both hit testing and painting those
     // floats.
     LayoutRect result;
     if (renderer()->isInline() && renderer()->isRenderInline()) {
         result = toRenderInline(renderer())->linesVisualOverflowBoundingBox();
     } else if (renderer()->isTableRow()) {
         // Our bounding box is just the union of all of our cells' border/overflow rects.
         for (LayoutObject* child = renderer()->slowFirstChild(); child; child = child->nextSibling()) {
             if (child->isTableCell()) {
-                LayoutRect bbox = toRenderBox(child)->borderBoxRect();
+                LayoutRect bbox = toLayoutBox(child)->borderBoxRect();
                 result.unite(bbox);
-                LayoutRect overflowRect = renderBox()->visualOverflowRect();
+                LayoutRect overflowRect = layoutBox()->visualOverflowRect();
                 if (bbox != overflowRect)
                     result.unite(overflowRect);
             }
         }
     } else {
-        RenderBox* box = renderBox();
+        LayoutBox* box = layoutBox();
         ASSERT(box);
         result = box->borderBoxRect();
         result.unite(box->visualOverflowRect());
     }
 
     ASSERT(renderer()->view());
     return result;
 }
 
 static inline LayoutRect flippedLogicalBoundingBox(LayoutRect boundingBox, LayoutObject* renderer)
 {
     LayoutRect result = boundingBox;
     if (renderer->isBox())
-        toRenderBox(renderer)->flipForWritingMode(result);
+        toLayoutBox(renderer)->flipForWritingMode(result);
     else
         renderer->containingBlock()->flipForWritingMode(result);
     return result;
 }
 
 LayoutRect Layer::physicalBoundingBox(const Layer* ancestorLayer, const LayoutPoint* offsetFromRoot) const
 {
     LayoutRect result = flippedLogicalBoundingBox(logicalBoundingBox(), renderer());
     if (offsetFromRoot)
         result.moveBy(*offsetFromRoot);
@@ skipping 312 matching lines @@
     // Some HTML can cause whitespace text nodes to have renderers, like:
     // <div>
     // <img src=...>
     // </div>
     // so test for 0x0 RenderTexts here
     for (LayoutObject* child = renderer()->slowFirstChild(); child; child = child->nextSibling()) {
         if (!child->hasLayer()) {
             if (child->isRenderInline() || !child->isBox())
                 return true;
 
-            if (toRenderBox(child)->size().width() > 0 || toRenderBox(child)->size().height() > 0)
+            if (toLayoutBox(child)->size().width() > 0 || toLayoutBox(child)->size().height() > 0)
                 return true;
         }
     }
     return false;
 }
 
 bool Layer::hasBoxDecorationsOrBackground() const
 {
     return renderer()->style()->hasBoxDecorations() || renderer()->style()->hasBackground();
 }
@@ skipping 187 matching lines @@
     computeSelfHitTestRects(rects);
     for (Layer* child = firstChild(); child; child = child->nextSibling())
         child->addLayerHitTestRects(rects);
 }
 
 void Layer::computeSelfHitTestRects(LayerHitTestRects& rects) const
 {
     if (!size().isEmpty()) {
         Vector<LayoutRect> rect;
 
-        if (renderBox() && renderBox()->scrollsOverflow()) {
+        if (layoutBox() && layoutBox()->scrollsOverflow()) {
             // For scrolling layers, rects are taken to be in the space of the contents.
             // We need to include the bounding box of the layer in the space of its parent
             // (eg. for border / scroll bars) and if it's composited then the entire contents
             // as well as they may be on another composited layer. Skip reporting contents
             // for non-composited layers as they'll get projected to the same layer as the
             // bounding box.
             if (compositingState() != NotComposited)
                 rect.append(m_scrollableArea->overflowRect());
 
             rects.set(this, rect);
@@ skipping 42 matching lines @@
     }
 }
 
 void showLayerTree(const blink::LayoutObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif