Move rendering/RenderBox to layout/LayoutBox.

Source/core/layout/LayoutReplaced.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011-2012. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 20 matching lines @@
 #include "core/rendering/RenderBlock.h"
 #include "core/rendering/RenderView.h"
 #include "platform/LengthFunctions.h"
 
 namespace blink {
 
 const int LayoutReplaced::defaultWidth = 300;
 const int LayoutReplaced::defaultHeight = 150;
 
 LayoutReplaced::LayoutReplaced(Element* element)
-    : RenderBox(element)
+    : LayoutBox(element)
     , m_intrinsicSize(defaultWidth, defaultHeight)
 {
     setReplaced(true);
 }
 
 LayoutReplaced::LayoutReplaced(Element* element, const LayoutSize& intrinsicSize)
-    : RenderBox(element)
+    : LayoutBox(element)
     , m_intrinsicSize(intrinsicSize)
 {
     setReplaced(true);
 }
 
 LayoutReplaced::~LayoutReplaced()
 {
 }
 
 void LayoutReplaced::willBeDestroyed()
 {
     if (!documentBeingDestroyed() && parent())
         parent()->dirtyLinesFromChangedChild(this);
 
-    RenderBox::willBeDestroyed();
+    LayoutBox::willBeDestroyed();
 }
 
 void LayoutReplaced::styleDidChange(StyleDifference diff, const LayoutStyle* oldStyle)
 {
-    RenderBox::styleDidChange(diff, oldStyle);
+    LayoutBox::styleDidChange(diff, oldStyle);
 
     bool hadStyle = (oldStyle != 0);
     float oldZoom = hadStyle ? oldStyle->effectiveZoom() : LayoutStyle::initialZoom();
     if (style() && style()->effectiveZoom() != oldZoom)
         intrinsicSizeChanged();
 }
 
 void LayoutReplaced::layout()
 {
     ASSERT(needsLayout());
@@ skipping 86 matching lines @@
     // this node to change it's preferred width because it maintains aspect ratio.
     return hasRelativeLogicalHeight() && style()->logicalWidth().isAuto() && !hasAutoHeightOrContainingBlockWithAutoHeight();
 }
 
 static inline bool rendererHasAspectRatio(const LayoutObject* renderer)
 {
     ASSERT(renderer);
     return renderer->isImage() || renderer->isCanvas() || renderer->isVideo();
 }
 
-void LayoutReplaced::computeAspectRatioInformationForRenderBox(RenderBox* contentRenderer, FloatSize& constrainedSize, double& intrinsicRatio) const
+void LayoutReplaced::computeAspectRatioInformationForLayoutBox(LayoutBox* contentRenderer, FloatSize& constrainedSize, double& intrinsicRatio) const
 {
     FloatSize intrinsicSize;
     if (contentRenderer) {
         contentRenderer->computeIntrinsicRatioInformation(intrinsicSize, intrinsicRatio);
 
         // Handle zoom & vertical writing modes here, as the embedded document doesn't know about them.
         intrinsicSize.scale(style()->effectiveZoom());
         if (isLayoutImage())
             intrinsicSize.scale(toLayoutImage(this)->imageDevicePixelRatio());
 
@@ skipping 17 matching lines @@
     // Now constrain the intrinsic size along each axis according to minimum and maximum width/heights along the
     // opposite axis. So for example a maximum width that shrinks our width will result in the height we compute here
     // having to shrink in order to preserve the aspect ratio. Because we compute these values independently along
     // each axis, the final returned size may in fact not preserve the aspect ratio.
     // FIXME: In the long term, it might be better to just return this code more to the way it used to be before this
     // function was added, since all it has done is make the code more unclear.
     constrainedSize = intrinsicSize;
     if (intrinsicRatio && !intrinsicSize.isEmpty() && style()->logicalWidth().isAuto() && style()->logicalHeight().isAuto()) {
         // We can't multiply or divide by 'intrinsicRatio' here, it breaks tests, like fast/images/zoomed-img-size.html, which
         // can only be fixed once subpixel precision is available for things like intrinsicWidth/Height - which include zoom!
-        constrainedSize.setWidth(RenderBox::computeReplacedLogicalHeight() * intrinsicSize.width() / intrinsicSize.height());
-        constrainedSize.setHeight(RenderBox::computeReplacedLogicalWidth() * intrinsicSize.height() / intrinsicSize.width());
+        constrainedSize.setWidth(LayoutBox::computeReplacedLogicalHeight() * intrinsicSize.width() / intrinsicSize.height());
+        constrainedSize.setHeight(LayoutBox::computeReplacedLogicalWidth() * intrinsicSize.height() / intrinsicSize.width());
     }
 }
 
 LayoutRect LayoutReplaced::replacedContentRect(const LayoutSize* overriddenIntrinsicSize) const
 {
     LayoutRect contentRect = contentBoxRect();
     ObjectFit objectFit = style()->objectFit();
 
     if (objectFit == ObjectFitFill && style()->objectPosition() == LayoutStyle::initialObjectPosition()) {
         return contentRect;
@@ skipping 39 matching lines @@
         return;
 
     intrinsicRatio = intrinsicSize.width() / intrinsicSize.height();
 }
 
 LayoutUnit LayoutReplaced::computeReplacedLogicalWidth(ShouldComputePreferred shouldComputePreferred) const
 {
     if (style()->logicalWidth().isSpecified() || style()->logicalWidth().isIntrinsic())
         return computeReplacedLogicalWidthRespectingMinMaxWidth(computeReplacedLogicalWidthUsing(style()->logicalWidth()), shouldComputePreferred);
 
-    RenderBox* contentRenderer = embeddedContentBox();
+    LayoutBox* contentRenderer = embeddedContentBox();
 
     // 10.3.2 Inline, replaced elements: http://www.w3.org/TR/CSS21/visudet.html#inline-replaced-width
     double intrinsicRatio = 0;
     FloatSize constrainedSize;
-    computeAspectRatioInformationForRenderBox(contentRenderer, constrainedSize, intrinsicRatio);
+    computeAspectRatioInformationForLayoutBox(contentRenderer, constrainedSize, intrinsicRatio);
 
     if (style()->logicalWidth().isAuto()) {
         bool computedHeightIsAuto = hasAutoHeightOrContainingBlockWithAutoHeight();
         bool hasIntrinsicWidth = constrainedSize.width() > 0;
 
         // If 'height' and 'width' both have computed values of 'auto' and the element also has an intrinsic width, then that intrinsic width is the used value of 'width'.
         if (computedHeightIsAuto && hasIntrinsicWidth)
             return computeReplacedLogicalWidthRespectingMinMaxWidth(constrainedSize.width(), shouldComputePreferred);
 
         bool hasIntrinsicHeight = constrainedSize.height() > 0;
@@ skipping 37 matching lines @@
 
     return computeReplacedLogicalWidthRespectingMinMaxWidth(intrinsicLogicalWidth(), shouldComputePreferred);
 }
 
 LayoutUnit LayoutReplaced::computeReplacedLogicalHeight() const
 {
     // 10.5 Content height: the 'height' property: http://www.w3.org/TR/CSS21/visudet.html#propdef-height
     if (hasReplacedLogicalHeight())
         return computeReplacedLogicalHeightRespectingMinMaxHeight(computeReplacedLogicalHeightUsing(style()->logicalHeight()));
 
-    RenderBox* contentRenderer = embeddedContentBox();
+    LayoutBox* contentRenderer = embeddedContentBox();
 
     // 10.6.2 Inline, replaced elements: http://www.w3.org/TR/CSS21/visudet.html#inline-replaced-height
     double intrinsicRatio = 0;
     FloatSize constrainedSize;
-    computeAspectRatioInformationForRenderBox(contentRenderer, constrainedSize, intrinsicRatio);
+    computeAspectRatioInformationForLayoutBox(contentRenderer, constrainedSize, intrinsicRatio);
 
     bool widthIsAuto = style()->logicalWidth().isAuto();
     bool hasIntrinsicHeight = constrainedSize.height() > 0;
 
     // If 'height' and 'width' both have computed values of 'auto' and the element also has an intrinsic height, then that intrinsic height is the used value of 'height'.
     if (widthIsAuto && hasIntrinsicHeight)
         return computeReplacedLogicalHeightRespectingMinMaxHeight(constrainedSize.height());
 
     // Otherwise, if 'height' has a computed value of 'auto', and the element has an intrinsic ratio then the used value of 'height' is:
     // (used width) / (intrinsic ratio)
@@ skipping 63 matching lines @@
 
     if (blockDirectionPosition >= bottom)
         return createPositionWithAffinity(caretMaxOffset(), DOWNSTREAM); // coordinates are below
 
     if (node()) {
         if (lineDirectionPosition <= logicalLeft() + (logicalWidth() / 2))
             return createPositionWithAffinity(0, DOWNSTREAM);
         return createPositionWithAffinity(1, DOWNSTREAM);
     }
 
-    return RenderBox::positionForPoint(point);
+    return LayoutBox::positionForPoint(point);
 }
 
 LayoutRect LayoutReplaced::selectionRectForPaintInvalidation(const LayoutBoxModelObject* paintInvalidationContainer) const
 {
     ASSERT(!needsLayout());
 
     if (!isSelected())
         return LayoutRect();
 
     LayoutRect rect = localSelectionRect();
@@ skipping 17 matching lines @@
     RootInlineBox& root = inlineBoxWrapper()->root();
     LayoutUnit newLogicalTop = root.block().style()->isFlippedBlocksWritingMode() ? inlineBoxWrapper()->logicalBottom() - root.selectionBottom() : root.selectionTop() - inlineBoxWrapper()->logicalTop();
     if (root.block().style()->isHorizontalWritingMode())
         return LayoutRect(0, newLogicalTop, size().width(), root.selectionHeight());
     return LayoutRect(newLogicalTop, 0, root.selectionHeight(), size().height());
 }
 
 void LayoutReplaced::setSelectionState(SelectionState state)
 {
     // The selection state for our containing block hierarchy is updated by the base class call.
-    RenderBox::setSelectionState(state);
+    LayoutBox::setSelectionState(state);
 
     if (!inlineBoxWrapper())
         return;
 
     // We only include the space below the baseline in our layer's cached paint invalidation rect if the
     // image is selected. Since the selection state has changed update the rect.
     if (hasLayer())
         setPreviousPaintInvalidationRect(boundsRectForPaintInvalidation(containerForPaintInvalidation()));
 
     if (canUpdateSelectionOnRootLineBoxes())
@@ skipping 28 matching lines @@
         return LayoutRect();
 
     // The selectionRect can project outside of the overflowRect, so take their union
     // for paint invalidation to avoid selection painting glitches.
     LayoutRect r = isSelected() ? localSelectionRect() : visualOverflowRect();
     mapRectToPaintInvalidationBacking(paintInvalidationContainer, r, paintInvalidationState);
     return r;
 }
 
 }