Move rendering/RenderBox to layout/LayoutBox.

Source/core/paint/BoxDecorationData.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/paint/BoxDecorationData.h"
 
+#include "core/layout/LayoutBox.h"
 #include "core/layout/style/BorderEdge.h"
 #include "core/layout/style/LayoutStyle.h"
-#include "core/rendering/RenderBox.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/graphics/GraphicsContext.h"
 
 namespace blink {
 
-BoxDecorationData::BoxDecorationData(const RenderBox& renderBox, GraphicsContext* context)
+BoxDecorationData::BoxDecorationData(const LayoutBox& layoutBox, GraphicsContext* context)
 {
-    backgroundColor = renderBox.style()->visitedDependentColor(CSSPropertyBackgroundColor);
-    hasBackground = backgroundColor.alpha() || renderBox.style()->hasBackgroundImage();
-    ASSERT(hasBackground == renderBox.style()->hasBackground());
-    hasBorder = renderBox.style()->hasBorder();
-    hasAppearance = renderBox.style()->hasAppearance();
+    backgroundColor = layoutBox.style()->visitedDependentColor(CSSPropertyBackgroundColor);
+    hasBackground = backgroundColor.alpha() || layoutBox.style()->hasBackgroundImage();
+    ASSERT(hasBackground == layoutBox.style()->hasBackground());
+    hasBorder = layoutBox.style()->hasBorder();
+    hasAppearance = layoutBox.style()->hasAppearance();
 
-    m_bleedAvoidance = determineBackgroundBleedAvoidance(renderBox, context);
+    m_bleedAvoidance = determineBackgroundBleedAvoidance(layoutBox, context);
 }
 
-BackgroundBleedAvoidance BoxDecorationData::determineBackgroundBleedAvoidance(const RenderBox& renderBox, GraphicsContext* context)
+BackgroundBleedAvoidance BoxDecorationData::determineBackgroundBleedAvoidance(const LayoutBox& layoutBox, GraphicsContext* context)
 {
-    if (renderBox.isDocumentElement())
+    if (layoutBox.isDocumentElement())
         return BackgroundBleedNone;
 
     if (!hasBackground)
         return BackgroundBleedNone;
 
-    if (!hasBorder || !renderBox.style()->hasBorderRadius() || renderBox.canRenderBorderImage()) {
-        if (renderBox.backgroundShouldAlwaysBeClipped())
+    if (!hasBorder || !layoutBox.style()->hasBorderRadius() || layoutBox.canRenderBorderImage()) {
+        if (layoutBox.backgroundShouldAlwaysBeClipped())
             return BackgroundBleedClipBackground;
         return BackgroundBleedNone;
     }
 
     // If display lists are enabled (via Slimming Paint), then simply clip the background and do not
     // perform advanced bleed-avoidance heuristics. These heuristics are not correct in the presence
     // of impl-side rasterization or layerization, since the actual pixel-relative scaling and rotation
     // of the content is not known to Blink.
     if (RuntimeEnabledFeatures::slimmingPaintEnabled())
         return BackgroundBleedClipBackground;
@@ skipping 10 matching lines @@
     // that borderObscuresBackgroundEdge can only return true if the border
     // widths are greater than 2 in both layout coordinates and screen
     // coordinates.
     // This precaution will become obsolete if RoundedRect is ever promoted to
     // a sub-pixel representation.
     if (contextScaling.width() > 1)
         contextScaling.setWidth(1);
     if (contextScaling.height() > 1)
         contextScaling.setHeight(1);
 
-    if (borderObscuresBackgroundEdge(*renderBox.style(), contextScaling))
+    if (borderObscuresBackgroundEdge(*layoutBox.style(), contextScaling))
         return BackgroundBleedShrinkBackground;
-    if (!hasAppearance && renderBox.style()->borderObscuresBackground() && renderBox.backgroundHasOpaqueTopLayer())
+    if (!hasAppearance && layoutBox.style()->borderObscuresBackground() && layoutBox.backgroundHasOpaqueTopLayer())
         return BackgroundBleedBackgroundOverBorder;
 
     return BackgroundBleedClipBackground;
 }
 
 bool BoxDecorationData::borderObscuresBackgroundEdge(const LayoutStyle& style, const FloatSize& contextScale) const
 {
     BorderEdge edges[4];
     style.getBorderEdgeInfo(edges);
 
     for (int i = BSTop; i <= BSLeft; ++i) {
         const BorderEdge& currEdge = edges[i];
         // FIXME: for vertical text
         float axisScale = (i == BSTop || i == BSBottom) ? contextScale.height() : contextScale.width();
         if (!currEdge.obscuresBackgroundEdge(axisScale))
             return false;
     }
 
     return true;
 }
 
 } // namespace blink