Move rendering/RenderBox to layout/LayoutBox.

Source/core/layout/LayoutObject.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 540 matching lines @@
         if (current->hasLayer())
             return toLayoutBoxModelObject(current)->layer();
     }
     // FIXME: we should get rid of detached render subtrees, at which point this code should
     // not be reached. crbug.com/411429
     return 0;
 }
 
 bool LayoutObject::scrollRectToVisible(const LayoutRect& rect, const ScrollAlignment& alignX, const ScrollAlignment& alignY)
 {
-    RenderBox* enclosingBox = this->enclosingBox();
+    LayoutBox* enclosingBox = this->enclosingBox();
     if (!enclosingBox)
         return false;
 
     enclosingBox->scrollRectToVisible(rect, alignX, alignY);
     return true;
 }
 
-RenderBox* LayoutObject::enclosingBox() const
+LayoutBox* LayoutObject::enclosingBox() const
 {
     LayoutObject* curr = const_cast<LayoutObject*>(this);
     while (curr) {
         if (curr->isBox())
-            return toRenderBox(curr);
+            return toLayoutBox(curr);
         curr = curr->parent();
     }
 
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 LayoutBoxModelObject* LayoutObject::enclosingBoxModelObject() const
 {
     LayoutObject* curr = const_cast<LayoutObject*>(this);
     while (curr) {
         if (curr->isBoxModelObject())
             return toLayoutBoxModelObject(curr);
         curr = curr->parent();
     }
 
     ASSERT_NOT_REACHED();
     return 0;
 }
 
-RenderBox* LayoutObject::enclosingScrollableBox() const
+LayoutBox* LayoutObject::enclosingScrollableBox() const
 {
     for (LayoutObject* ancestor = parent(); ancestor; ancestor = ancestor->parent()) {
         if (!ancestor->isBox())
             continue;
 
-        RenderBox* ancestorBox = toRenderBox(ancestor);
+        LayoutBox* ancestorBox = toLayoutBox(ancestor);
         if (ancestorBox->canBeScrolledAndHasScrollableArea())
             return ancestorBox;
     }
 
     return 0;
 }
 
 LayoutFlowThread* LayoutObject::locateFlowThreadContainingBlock() const
 {
     ASSERT(flowThreadState() != NotInsideFlowThread);
@@ skipping 773 matching lines @@
     }
 
     if (LayoutObject* o = parent()) {
         if (o->isRenderBlockFlow()) {
             RenderBlock* cb = toRenderBlock(o);
             if (cb->hasColumns())
                 cb->adjustRectForColumns(rect);
         }
 
         if (o->hasOverflowClip()) {
-            RenderBox* boxParent = toRenderBox(o);
+            LayoutBox* boxParent = toLayoutBox(o);
             boxParent->applyCachedClipAndScrollOffsetForPaintInvalidation(rect);
             if (rect.isEmpty())
                 return;
         }
 
         o->mapRectToPaintInvalidationBacking(paintInvalidationContainer, rect, paintInvalidationState);
     }
 }
 
 void LayoutObject::dirtyLinesFromChangedChild(LayoutObject*)
@@ skipping 300 matching lines @@
         // Keep layer hierarchy visibility bits up to date if visibility changes.
         if (m_style->visibility() != newStyle.visibility()) {
             // We might not have an enclosing layer yet because we might not be in the tree.
             if (Layer* layer = enclosingLayer())
                 layer->potentiallyDirtyVisibleContentStatus(newStyle.visibility());
         }
 
         if (isFloating() && (m_style->floating() != newStyle.floating())) {
             // For changes in float styles, we need to conceivably remove ourselves
             // from the floating objects list.
-            toRenderBox(this)->removeFloatingOrPositionedChildFromBlockLists();
+            toLayoutBox(this)->removeFloatingOrPositionedChildFromBlockLists();
         } else if (isOutOfFlowPositioned() && (m_style->position() != newStyle.position())) {
             // For changes in positioning styles, we need to conceivably remove ourselves
             // from the positioned objects list.
-            toRenderBox(this)->removeFloatingOrPositionedChildFromBlockLists();
+            toLayoutBox(this)->removeFloatingOrPositionedChildFromBlockLists();
         }
 
         s_affectsParentBlock = isFloatingOrOutOfFlowPositioned()
             && (!newStyle.isFloating() && !newStyle.hasOutOfFlowPosition())
             && parent() && (parent()->isRenderBlockFlow() || parent()->isRenderInline());
 
         // Clearing these bits is required to avoid leaving stale renderers.
         // FIXME: We shouldn't need that hack if our logic was totally correct.
         if (diff.needsLayout()) {
             setFloating(false);
@@ skipping 204 matching lines @@
         return;
 
     LayoutObject* o = parent();
     if (!o)
         return;
 
     // FIXME: this should call offsetFromContainer to share code, but I'm not sure it's ever called.
     LayoutPoint centerPoint = roundedLayoutPoint(transformState.mappedPoint());
     if (mode & ApplyContainerFlip && o->isBox()) {
         if (o->style()->isFlippedBlocksWritingMode())
-            transformState.move(toRenderBox(o)->flipForWritingModeIncludingColumns(roundedLayoutPoint(transformState.mappedPoint())) - centerPoint);
+            transformState.move(toLayoutBox(o)->flipForWritingModeIncludingColumns(roundedLayoutPoint(transformState.mappedPoint())) - centerPoint);
         mode &= ~ApplyContainerFlip;
     }
 
     transformState.move(o->columnOffset(roundedLayoutPoint(transformState.mappedPoint())));
 
     if (o->hasOverflowClip())
-        transformState.move(-toRenderBox(o)->scrolledContentOffset());
+        transformState.move(-toLayoutBox(o)->scrolledContentOffset());
 
     o->mapLocalToContainer(paintInvalidationContainer, transformState, mode, wasFixed, paintInvalidationState);
 }
 
 const LayoutObject* LayoutObject::pushMappingToContainer(const LayoutBoxModelObject* ancestorToStopAt, LayoutGeometryMap& geometryMap) const
 {
     ASSERT_UNUSED(ancestorToStopAt, ancestorToStopAt != this);
 
     LayoutObject* container = parent();
     if (!container)
         return 0;
 
     // FIXME: this should call offsetFromContainer to share code, but I'm not sure it's ever called.
     LayoutSize offset;
     if (container->hasOverflowClip())
-        offset = -LayoutSize(toRenderBox(container)->scrolledContentOffset());
+        offset = -LayoutSize(toLayoutBox(container)->scrolledContentOffset());
 
     geometryMap.push(this, offset, hasColumns());
 
     return container;
 }
 
 void LayoutObject::mapAbsoluteToLocalPoint(MapCoordinatesFlags mode, TransformState& transformState) const
 {
     LayoutObject* o = parent();
     if (o) {
         o->mapAbsoluteToLocalPoint(mode, transformState);
         if (o->hasOverflowClip())
-            transformState.move(toRenderBox(o)->scrolledContentOffset());
+            transformState.move(toLayoutBox(o)->scrolledContentOffset());
     }
 }
 
 bool LayoutObject::shouldUseTransformFromContainer(const LayoutObject* containerObject) const
 {
     // hasTransform() indicates whether the object has transform, transform-style or perspective. We just care about transform,
     // so check the layer's transform directly.
     return (hasLayer() && toLayoutBoxModelObject(this)->layer()->transform()) || (containerObject && containerObject->style()->hasPerspective());
 }
 
@@ skipping 58 matching lines @@
     return containerPoint;
 }
 
 LayoutSize LayoutObject::offsetFromContainer(const LayoutObject* o, const LayoutPoint& point, bool* offsetDependsOnPoint) const
 {
     ASSERT(o == container());
 
     LayoutSize offset = o->columnOffset(point);
 
     if (o->hasOverflowClip())
-        offset -= toRenderBox(o)->scrolledContentOffset();
+        offset -= toLayoutBox(o)->scrolledContentOffset();
 
     if (offsetDependsOnPoint)
         *offsetDependsOnPoint = hasColumns() || o->isLayoutFlowThread();
 
     return offset;
 }
 
 LayoutSize LayoutObject::offsetFromAncestorContainer(const LayoutObject* container) const
 {
     if (container == this)
@@ skipping 34 matching lines @@
 
     if (!hasLayer()) {
         LayoutObject* container = this->container();
         currentLayer = container->enclosingLayer();
         if (container && currentLayer->renderer() != container) {
             layerOffset.move(container->offsetFromAncestorContainer(currentLayer->renderer()));
             // If the layer itself is scrolled, we have to undo the subtraction of its scroll
             // offset since we want the offset relative to the scrolling content, not the
             // element itself.
             if (currentLayer->renderer()->hasOverflowClip())
-                layerOffset.move(currentLayer->renderBox()->scrolledContentOffset());
+                layerOffset.move(currentLayer->layoutBox()->scrolledContentOffset());
         }
     }
 
     this->addLayerHitTestRects(layerRects, currentLayer, layerOffset, LayoutRect());
 }
 
 void LayoutObject::addLayerHitTestRects(LayerHitTestRects& layerRects, const Layer* currentLayer, const LayoutPoint& layerOffset, const LayoutRect& containerRect) const
 {
     ASSERT(currentLayer);
     ASSERT(currentLayer == this->enclosingLayer());
@@ skipping 652 matching lines @@
 
 void LayoutObject::addAnnotatedRegions(Vector<AnnotatedRegionValue>& regions)
 {
     // Convert the style regions to absolute coordinates.
     if (style()->visibility() != VISIBLE || !isBox())
         return;
 
     if (style()->getDraggableRegionMode() == DraggableRegionNone)
         return;
 
-    RenderBox* box = toRenderBox(this);
+    LayoutBox* box = toLayoutBox(this);
     FloatRect localBounds(FloatPoint(), FloatSize(box->size()));
     FloatRect absBounds = localToAbsoluteQuad(localBounds).boundingBox();
 
     AnnotatedRegionValue region;
     region.draggable = style()->getDraggableRegionMode() == DraggableRegionDrag;
     region.bounds = LayoutRect(absBounds);
     regions.append(region);
 }
 
 void LayoutObject::collectAnnotatedRegions(Vector<AnnotatedRegionValue>& regions)
@@ skipping 390 matching lines @@
 {
     if (object1) {
         const blink::LayoutObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showRenderTreeAndMark(object1, "*", object2, "-", 0);
     }
 }
 
 #endif