Move rendering/RenderBox to layout/LayoutBox.

Source/core/css/LayoutStyleCSSValueMapping.cpp

 /*
  * Copyright (C) 2004 Zack Rusin <zack@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>
  * Copyright (C) 2011 Sencha, Inc. All rights reserved.
  * Copyright (C) 2015 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ skipping 25 matching lines @@
 #include "core/css/CSSGridTemplateAreasValue.h"
 #include "core/css/CSSPathValue.h"
 #include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/CSSReflectValue.h"
 #include "core/css/CSSShadowValue.h"
 #include "core/css/CSSTimingFunctionValue.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/CSSValuePool.h"
 #include "core/css/Pair.h"
 #include "core/css/Rect.h"
+#include "core/layout/LayoutBox.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/style/ContentData.h"
 #include "core/layout/style/LayoutStyle.h"
 #include "core/layout/style/PathStyleMotionPath.h"
 #include "core/layout/style/ShadowList.h"
 #include "core/rendering/RenderBlock.h"
-#include "core/rendering/RenderBox.h"
 #include "core/rendering/RenderGrid.h"
 #include "platform/LengthFunctions.h"
 
 namespace blink {
 
 inline static PassRefPtrWillBeRawPtr<CSSPrimitiveValue> zoomAdjustedPixelValue(double value, const LayoutStyle& style)
 {
     return cssValuePool().createValue(adjustFloatForAbsoluteZoom(value, style), CSSPrimitiveValue::CSS_PX);
 }
 
@@ skipping 94 matching lines @@
         break;
     case CSSPropertyBottom:
         offset = style.bottom();
         break;
     default:
         return nullptr;
     }
 
     if (offset.isPercent() && renderer && renderer->isBox()) {
         LayoutUnit containingBlockSize = (propertyID == CSSPropertyLeft || propertyID == CSSPropertyRight) ?
-            toRenderBox(renderer)->containingBlockLogicalWidthForContent() :
-            toRenderBox(renderer)->containingBlockLogicalHeightForContent(ExcludeMarginBorderPadding);
+            toLayoutBox(renderer)->containingBlockLogicalWidthForContent() :
+            toLayoutBox(renderer)->containingBlockLogicalHeightForContent(ExcludeMarginBorderPadding);
         return zoomAdjustedPixelValue(valueForLength(offset, containingBlockSize), style);
     }
     if (offset.isAuto()) {
         // FIXME: It's not enough to simply return "auto" values for one offset if the other side is defined.
         // In other words if left is auto and right is not auto, then left's computed value is negative right().
         // So we should get the opposite length unit and see if it is auto.
         return cssValuePool().createIdentifierValue(CSSValueAuto);
     }
 
     return zoomAdjustedPixelValueForLength(offset, style);
@@ skipping 449 matching lines @@
     if (!position.namedGridLine().isNull())
         list->append(cssValuePool().createValue(position.namedGridLine(), CSSPrimitiveValue::CSS_STRING));
     return list;
 }
 
 static LayoutRect sizingBox(const LayoutObject* renderer)
 {
     if (!renderer->isBox())
         return LayoutRect();
 
-    const RenderBox* box = toRenderBox(renderer);
+    const LayoutBox* box = toLayoutBox(renderer);
     return box->style()->boxSizing() == BORDER_BOX ? box->borderBoxRect() : box->computedCSSContentBoxRect();
 }
 
 static PassRefPtrWillBeRawPtr<CSSValue> scrollBlocksOnFlagsToCSSValue(WebScrollBlocksOn scrollBlocksOn)
 {
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
 
     if (scrollBlocksOn == WebScrollBlocksOnNone)
         return cssValuePool().createIdentifierValue(CSSValueNone);
 
@@ skipping 271 matching lines @@
     return transformValue.release();
 }
 
 static PassRefPtrWillBeRawPtr<CSSValue> computedTransform(const LayoutObject* renderer, const LayoutStyle& style)
 {
     if (!renderer || !renderer->hasTransformRelatedProperty() || !style.hasTransform())
         return cssValuePool().createIdentifierValue(CSSValueNone);
 
     IntRect box;
     if (renderer->isBox())
-        box = pixelSnappedIntRect(toRenderBox(renderer)->borderBoxRect());
+        box = pixelSnappedIntRect(toLayoutBox(renderer)->borderBoxRect());
 
     TransformationMatrix transform;
     style.applyTransform(transform, LayoutSize(box.size()), LayoutStyle::ExcludeTransformOrigin, LayoutStyle::ExcludeMotionPath);
 
     // FIXME: Need to print out individual functions (https://bugs.webkit.org/show_bug.cgi?id=23924)
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     list->append(valueForMatrixTransform(transform, style));
 
     return list.release();
 }
@@ skipping 748 matching lines @@
     case CSSPropertyListStyleType:
         return cssValuePool().createValue(style.listStyleType());
     case CSSPropertyWebkitLocale:
         if (style.locale().isNull())
             return cssValuePool().createIdentifierValue(CSSValueAuto);
         return cssValuePool().createValue(style.locale(), CSSPrimitiveValue::CSS_STRING);
     case CSSPropertyMarginTop: {
         Length marginTop = style.marginTop();
         if (marginTop.isFixed() || !renderer || !renderer->isBox())
             return zoomAdjustedPixelValueForLength(marginTop, style);
-        return zoomAdjustedPixelValue(toRenderBox(renderer)->marginTop(), style);
+        return zoomAdjustedPixelValue(toLayoutBox(renderer)->marginTop(), style);
     }
     case CSSPropertyMarginRight: {
         Length marginRight = style.marginRight();
         if (marginRight.isFixed() || !renderer || !renderer->isBox())
             return zoomAdjustedPixelValueForLength(marginRight, style);
         float value;
         if (marginRight.isPercent()) {
-            // RenderBox gives a marginRight() that is the distance between the right-edge of the child box
+            // LayoutBox gives a marginRight() that is the distance between the right-edge of the child box
             // and the right-edge of the containing box, when display == BLOCK. Let's calculate the absolute
-            // value of the specified margin-right % instead of relying on RenderBox's marginRight() value.
-            value = minimumValueForLength(marginRight, toRenderBox(renderer)->containingBlockLogicalWidthForContent()).toFloat();
+            // value of the specified margin-right % instead of relying on LayoutBox's marginRight() value.
+            value = minimumValueForLength(marginRight, toLayoutBox(renderer)->containingBlockLogicalWidthForContent()).toFloat();
         } else {
-            value = toRenderBox(renderer)->marginRight().toFloat();
+            value = toLayoutBox(renderer)->marginRight().toFloat();
         }
         return zoomAdjustedPixelValue(value, style);
     }
     case CSSPropertyMarginBottom: {
         Length marginBottom = style.marginBottom();
         if (marginBottom.isFixed() || !renderer || !renderer->isBox())
             return zoomAdjustedPixelValueForLength(marginBottom, style);
-        return zoomAdjustedPixelValue(toRenderBox(renderer)->marginBottom(), style);
+        return zoomAdjustedPixelValue(toLayoutBox(renderer)->marginBottom(), style);
     }
     case CSSPropertyMarginLeft: {
         Length marginLeft = style.marginLeft();
         if (marginLeft.isFixed() || !renderer || !renderer->isBox())
             return zoomAdjustedPixelValueForLength(marginLeft, style);
-        return zoomAdjustedPixelValue(toRenderBox(renderer)->marginLeft(), style);
+        return zoomAdjustedPixelValue(toLayoutBox(renderer)->marginLeft(), style);
     }
     case CSSPropertyWebkitUserModify:
         return cssValuePool().createValue(style.userModify());
     case CSSPropertyMaxHeight: {
         const Length& maxHeight = style.maxHeight();
         if (maxHeight.isMaxSizeNone())
             return cssValuePool().createIdentifierValue(CSSValueNone);
         return zoomAdjustedPixelValueForLength(maxHeight, style);
     }
     case CSSPropertyMaxWidth: {
@@ skipping 41 matching lines @@
     case CSSPropertyOverflowWrap:
         return cssValuePool().createValue(style.overflowWrap());
     case CSSPropertyOverflowX:
         return cssValuePool().createValue(style.overflowX());
     case CSSPropertyOverflowY:
         return cssValuePool().createValue(style.overflowY());
     case CSSPropertyPaddingTop: {
         Length paddingTop = style.paddingTop();
         if (paddingTop.isFixed() || !renderer || !renderer->isBox())
             return zoomAdjustedPixelValueForLength(paddingTop, style);
-        return zoomAdjustedPixelValue(toRenderBox(renderer)->computedCSSPaddingTop(), style);
+        return zoomAdjustedPixelValue(toLayoutBox(renderer)->computedCSSPaddingTop(), style);
     }
     case CSSPropertyPaddingRight: {
         Length paddingRight = style.paddingRight();
         if (paddingRight.isFixed() || !renderer || !renderer->isBox())
             return zoomAdjustedPixelValueForLength(paddingRight, style);
-        return zoomAdjustedPixelValue(toRenderBox(renderer)->computedCSSPaddingRight(), style);
+        return zoomAdjustedPixelValue(toLayoutBox(renderer)->computedCSSPaddingRight(), style);
     }
     case CSSPropertyPaddingBottom: {
         Length paddingBottom = style.paddingBottom();
         if (paddingBottom.isFixed() || !renderer || !renderer->isBox())
             return zoomAdjustedPixelValueForLength(paddingBottom, style);
-        return zoomAdjustedPixelValue(toRenderBox(renderer)->computedCSSPaddingBottom(), style);
+        return zoomAdjustedPixelValue(toLayoutBox(renderer)->computedCSSPaddingBottom(), style);
     }
     case CSSPropertyPaddingLeft: {
         Length paddingLeft = style.paddingLeft();
         if (paddingLeft.isFixed() || !renderer || !renderer->isBox())
             return zoomAdjustedPixelValueForLength(paddingLeft, style);
-        return zoomAdjustedPixelValue(toRenderBox(renderer)->computedCSSPaddingLeft(), style);
+        return zoomAdjustedPixelValue(toLayoutBox(renderer)->computedCSSPaddingLeft(), style);
     }
     case CSSPropertyPageBreakAfter:
         return cssValuePool().createValue(style.pageBreakAfter());
     case CSSPropertyPageBreakBefore:
         return cssValuePool().createValue(style.pageBreakBefore());
     case CSSPropertyPageBreakInside: {
         EPageBreak pageBreak = style.pageBreakInside();
         ASSERT(pageBreak != PBALWAYS);
         if (pageBreak == PBALWAYS)
             return nullptr;
@@ skipping 336 matching lines @@
     case CSSPropertyWebkitPerspective:
         if (!style.hasPerspective())
             return cssValuePool().createIdentifierValue(CSSValueNone);
         return zoomAdjustedPixelValue(style.perspective(), style);
     case CSSPropertyPerspectiveOrigin:
     case CSSPropertyWebkitPerspectiveOrigin: {
         RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
         if (renderer) {
             LayoutRect box;
             if (renderer->isBox())
-                box = toRenderBox(renderer)->borderBoxRect();
+                box = toLayoutBox(renderer)->borderBoxRect();
 
             list->append(zoomAdjustedPixelValue(minimumValueForLength(style.perspectiveOriginX(), box.width()), style));
             list->append(zoomAdjustedPixelValue(minimumValueForLength(style.perspectiveOriginY(), box.height()), style));
         } else {
             list->append(zoomAdjustedPixelValueForLength(style.perspectiveOriginX(), style));
             list->append(zoomAdjustedPixelValueForLength(style.perspectiveOriginY(), style));
         }
         return list.release();
     }
     case CSSPropertyWebkitRtlOrdering:
@@ skipping 26 matching lines @@
         return cssValuePool().createValue(style.speak());
     case CSSPropertyTransform:
     case CSSPropertyWebkitTransform:
         return computedTransform(renderer, style);
     case CSSPropertyTransformOrigin:
     case CSSPropertyWebkitTransformOrigin: {
         RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
         if (renderer) {
             LayoutRect box;
             if (renderer->isBox())
-                box = toRenderBox(renderer)->borderBoxRect();
+                box = toLayoutBox(renderer)->borderBoxRect();
 
             list->append(zoomAdjustedPixelValue(minimumValueForLength(style.transformOriginX(), box.width()), style));
             list->append(zoomAdjustedPixelValue(minimumValueForLength(style.transformOriginY(), box.height()), style));
             if (style.transformOriginZ() != 0)
                 list->append(zoomAdjustedPixelValue(style.transformOriginZ(), style));
         } else {
             list->append(zoomAdjustedPixelValueForLength(style.transformOriginX(), style));
             list->append(zoomAdjustedPixelValueForLength(style.transformOriginY(), style));
             if (style.transformOriginZ() != 0)
                 list->append(zoomAdjustedPixelValue(style.transformOriginZ(), style));
@@ skipping 343 matching lines @@
         return zoomAdjustedPixelValueForLength(svgStyle.y(), style);
 
     case CSSPropertyAll:
         return nullptr;
     }
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 }