Move rendering/RenderBox to layout/LayoutBox.

Source/core/paint/BoxPainter.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/BoxPainter.h"
 
 #include "core/HTMLNames.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/layout/ImageQualityController.h"
 #include "core/layout/Layer.h"
+#include "core/layout/LayoutBox.h"
 #include "core/layout/LayoutBoxModelObject.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutTable.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/layout/PaintInfo.h"
 #include "core/layout/compositing/CompositedLayerMapping.h"
 #include "core/layout/style/BorderEdge.h"
 #include "core/layout/style/ShadowList.h"
 #include "core/paint/BackgroundImageGeometry.h"
 #include "core/paint/BoxDecorationData.h"
 #include "core/paint/RenderDrawingRecorder.h"
 #include "core/paint/RoundedInnerRectClipper.h"
-#include "core/rendering/RenderBox.h"
 #include "core/rendering/RenderView.h"
 #include "platform/LengthFunctions.h"
 #include "platform/geometry/LayoutPoint.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
 #include "platform/graphics/paint/CompositingDisplayItem.h"
 
 namespace blink {
 
 void BoxPainter::paint(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
-    LayoutPoint adjustedPaintOffset = paintOffset + m_renderBox.location();
+    LayoutPoint adjustedPaintOffset = paintOffset + m_layoutBox.location();
     // default implementation. Just pass paint through to the children
     PaintInfo childInfo(paintInfo);
-    childInfo.updatePaintingRootForChildren(&m_renderBox);
-    for (LayoutObject* child = m_renderBox.slowFirstChild(); child; child = child->nextSibling())
+    childInfo.updatePaintingRootForChildren(&m_layoutBox);
+    for (LayoutObject* child = m_layoutBox.slowFirstChild(); child; child = child->nextSibling())
         child->paint(childInfo, adjustedPaintOffset);
 }
 
 void BoxPainter::paintBoxDecorationBackground(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
-    if (!paintInfo.shouldPaintWithinRoot(&m_renderBox))
+    if (!paintInfo.shouldPaintWithinRoot(&m_layoutBox))
         return;
 
-    LayoutRect paintRect = m_renderBox.borderBoxRect();
+    LayoutRect paintRect = m_layoutBox.borderBoxRect();
     paintRect.moveBy(paintOffset);
     paintBoxDecorationBackgroundWithRect(paintInfo, paintOffset, paintRect);
 }
 
 LayoutRect BoxPainter::boundsForDrawingRecorder(const LayoutPoint& paintOffset)
 {
     if (!RuntimeEnabledFeatures::slimmingPaintEnabled())
         return LayoutRect();
 
     // The document element is specified to paint its background infinitely.
-    if (m_renderBox.isDocumentElement())
+    if (m_layoutBox.isDocumentElement())
         return scrolledBackgroundRect();
 
     // Use the visual overflow rect here, because it will include overflow introduced by the theme.
-    LayoutRect bounds = m_renderBox.visualOverflowRect();
+    LayoutRect bounds = m_layoutBox.visualOverflowRect();
     bounds.moveBy(paintOffset);
     return pixelSnappedIntRect(bounds);
 }
 
 LayoutRect BoxPainter::scrolledBackgroundRect()
 {
-    RenderView* renderView = m_renderBox.view();
-    LayoutRect result = renderView->backgroundRect(&m_renderBox);
+    RenderView* renderView = m_layoutBox.view();
+    LayoutRect result = renderView->backgroundRect(&m_layoutBox);
     if (renderView->hasOverflowClip())
         result.move(-renderView->scrolledContentOffset());
     return result;
 }
 
 void BoxPainter::paintBoxDecorationBackgroundWithRect(const PaintInfo& paintInfo, const LayoutPoint& paintOffset, const LayoutRect& paintRect)
 {
-    RenderDrawingRecorder recorder(paintInfo.context, m_renderBox, DisplayItem::BoxDecorationBackground, boundsForDrawingRecorder(paintOffset));
+    RenderDrawingRecorder recorder(paintInfo.context, m_layoutBox, DisplayItem::BoxDecorationBackground, boundsForDrawingRecorder(paintOffset));
     if (recorder.canUseCachedDrawing())
         return;
 
-    const LayoutStyle& style = m_renderBox.styleRef();
-    BoxDecorationData boxDecorationData(m_renderBox, paintInfo.context);
+    const LayoutStyle& style = m_layoutBox.styleRef();
+    BoxDecorationData boxDecorationData(m_layoutBox, paintInfo.context);
 
     // FIXME: Should eventually give the theme control over whether the box shadow should paint, since controls could have
     // custom shadows of their own.
-    if (!m_renderBox.boxShadowShouldBeAppliedToBackground(boxDecorationData.bleedAvoidance()))
+    if (!m_layoutBox.boxShadowShouldBeAppliedToBackground(boxDecorationData.bleedAvoidance()))
         paintBoxShadow(paintInfo, paintRect, style, Normal);
 
     GraphicsContextStateSaver stateSaver(*paintInfo.context, false);
     if (boxDecorationData.bleedAvoidance() == BackgroundBleedClipBackground) {
         stateSaver.save();
         FloatRoundedRect border = style.getRoundedBorderFor(paintRect);
         paintInfo.context->clipRoundedRect(border);
     }
 
     // If we have a native theme appearance, paint that before painting our background.
     // The theme will tell us whether or not we should also paint the CSS background.
     IntRect snappedPaintRect(pixelSnappedIntRect(paintRect));
-    bool themePainted = boxDecorationData.hasAppearance && !LayoutTheme::theme().paint(&m_renderBox, paintInfo, snappedPaintRect);
+    bool themePainted = boxDecorationData.hasAppearance && !LayoutTheme::theme().paint(&m_layoutBox, paintInfo, snappedPaintRect);
     if (!themePainted) {
         if (boxDecorationData.bleedAvoidance() == BackgroundBleedBackgroundOverBorder)
-            paintBorder(m_renderBox, paintInfo, paintRect, style, boxDecorationData.bleedAvoidance());
+            paintBorder(m_layoutBox, paintInfo, paintRect, style, boxDecorationData.bleedAvoidance());
 
         paintBackground(paintInfo, paintRect, boxDecorationData.backgroundColor, boxDecorationData.bleedAvoidance());
 
         if (boxDecorationData.hasAppearance)
-            LayoutTheme::theme().paintDecorations(&m_renderBox, paintInfo, snappedPaintRect);
+            LayoutTheme::theme().paintDecorations(&m_layoutBox, paintInfo, snappedPaintRect);
     }
     paintBoxShadow(paintInfo, paintRect, style, Inset);
 
     // The theme will tell us whether or not we should also paint the CSS border.
     if (boxDecorationData.hasBorder && boxDecorationData.bleedAvoidance() != BackgroundBleedBackgroundOverBorder
-        && (!boxDecorationData.hasAppearance || (!themePainted && LayoutTheme::theme().paintBorderOnly(&m_renderBox, paintInfo, snappedPaintRect)))
-        && !(m_renderBox.isTable() && toLayoutTable(&m_renderBox)->collapseBorders()))
-        paintBorder(m_renderBox, paintInfo, paintRect, style, boxDecorationData.bleedAvoidance());
+        && (!boxDecorationData.hasAppearance || (!themePainted && LayoutTheme::theme().paintBorderOnly(&m_layoutBox, paintInfo, snappedPaintRect)))
+        && !(m_layoutBox.isTable() && toLayoutTable(&m_layoutBox)->collapseBorders()))
+        paintBorder(m_layoutBox, paintInfo, paintRect, style, boxDecorationData.bleedAvoidance());
 }
 
-static bool skipBodyBackground(const RenderBox* bodyElementRenderer)
+static bool skipBodyBackground(const LayoutBox* bodyElementRenderer)
 {
     ASSERT(bodyElementRenderer->isBody());
     // The <body> only paints its background if the root element has defined a background independent of the body,
     // or if the <body>'s parent is not the document element's renderer (e.g. inside SVG foreignObject).
     LayoutObject* documentElementRenderer = bodyElementRenderer->document().documentElement()->renderer();
     return documentElementRenderer
         && !documentElementRenderer->hasBackground()
         && (documentElementRenderer == bodyElementRenderer->parent());
 }
 
 void BoxPainter::paintBackground(const PaintInfo& paintInfo, const LayoutRect& paintRect, const Color& backgroundColor, BackgroundBleedAvoidance bleedAvoidance)
 {
-    if (m_renderBox.isDocumentElement()) {
+    if (m_layoutBox.isDocumentElement()) {
         paintRootBoxFillLayers(paintInfo);
         return;
     }
-    if (m_renderBox.isBody() && skipBodyBackground(&m_renderBox))
+    if (m_layoutBox.isBody() && skipBodyBackground(&m_layoutBox))
         return;
-    if (m_renderBox.boxDecorationBackgroundIsKnownToBeObscured())
+    if (m_layoutBox.boxDecorationBackgroundIsKnownToBeObscured())
         return;
-    paintFillLayers(paintInfo, backgroundColor, m_renderBox.style()->backgroundLayers(), paintRect, bleedAvoidance);
+    paintFillLayers(paintInfo, backgroundColor, m_layoutBox.style()->backgroundLayers(), paintRect, bleedAvoidance);
 }
 
 void BoxPainter::paintRootBoxFillLayers(const PaintInfo& paintInfo)
 {
     if (paintInfo.skipRootBackground())
         return;
 
-    LayoutObject* rootBackgroundRenderer = m_renderBox.rendererForRootBackground();
+    LayoutObject* rootBackgroundRenderer = m_layoutBox.rendererForRootBackground();
 
     const FillLayer& bgLayer = rootBackgroundRenderer->style()->backgroundLayers();
     Color bgColor = rootBackgroundRenderer->resolveColor(CSSPropertyBackgroundColor);
 
     paintFillLayers(paintInfo, bgColor, bgLayer, scrolledBackgroundRect(), BackgroundBleedNone, SkXfermode::kSrcOver_Mode, rootBackgroundRenderer);
 }
 
 void BoxPainter::paintFillLayers(const PaintInfo& paintInfo, const Color& c, const FillLayer& fillLayer, const LayoutRect& rect,
     BackgroundBleedAvoidance bleedAvoidance, SkXfermode::Mode op, LayoutObject* backgroundObject)
 {
     Vector<const FillLayer*, 8> layers;
     const FillLayer* curLayer = &fillLayer;
     bool shouldDrawBackgroundInSeparateBuffer = false;
     bool isBottomLayerOccluded = false;
     while (curLayer) {
         layers.append(curLayer);
         // Stop traversal when an opaque layer is encountered.
         // FIXME : It would be possible for the following occlusion culling test to be more aggressive
         // on layers with no repeat by testing whether the image covers the layout rect.
         // Testing that here would imply duplicating a lot of calculations that are currently done in
         // LayoutBoxModelObject::paintFillLayerExtended. A more efficient solution might be to move
         // the layer recursion into paintFillLayerExtended, or to compute the layer geometry here
         // and pass it down.
 
         if (!shouldDrawBackgroundInSeparateBuffer && curLayer->blendMode() != WebBlendModeNormal)
             shouldDrawBackgroundInSeparateBuffer = true;
 
         // The clipOccludesNextLayers condition must be evaluated first to avoid short-circuiting.
         if (curLayer->clipOccludesNextLayers(curLayer == &fillLayer)
-            && curLayer->hasOpaqueImage(&m_renderBox)
-            && curLayer->image()->canRender(m_renderBox, m_renderBox.style()->effectiveZoom())
+            && curLayer->hasOpaqueImage(&m_layoutBox)
+            && curLayer->image()->canRender(m_layoutBox, m_layoutBox.style()->effectiveZoom())
             && curLayer->hasRepeatXY()
             && curLayer->blendMode() == WebBlendModeNormal
-            && !m_renderBox.boxShadowShouldBeAppliedToBackground(bleedAvoidance))
+            && !m_layoutBox.boxShadowShouldBeAppliedToBackground(bleedAvoidance))
             break;
         curLayer = curLayer->next();
     }
 
     if (layers.size() > 0  && (**layers.rbegin()).next())
         isBottomLayerOccluded = true;
 
     GraphicsContext* context = paintInfo.context;
     if (!context)
         shouldDrawBackgroundInSeparateBuffer = false;
 
     bool skipBaseColor = false;
     if (shouldDrawBackgroundInSeparateBuffer) {
         bool isBaseColorVisible = !isBottomLayerOccluded && c.hasAlpha();
 
         // Paint the document's base background color outside the transparency layer,
         // so that the background images don't blend with this color: http://crbug.com/389039.
-        if (isBaseColorVisible && isDocumentElementWithOpaqueBackground(m_renderBox)) {
-            paintRootBackgroundColor(m_renderBox, paintInfo, rect, Color());
+        if (isBaseColorVisible && isDocumentElementWithOpaqueBackground(m_layoutBox)) {
+            paintRootBackgroundColor(m_layoutBox, paintInfo, rect, Color());
             skipBaseColor = true;
         }
         context->beginTransparencyLayer(1);
     }
 
     Vector<const FillLayer*>::const_reverse_iterator topLayer = layers.rend();
     for (Vector<const FillLayer*>::const_reverse_iterator it = layers.rbegin(); it != topLayer; ++it)
         paintFillLayer(paintInfo, c, **it, rect, bleedAvoidance, op, backgroundObject, skipBaseColor);
 
     if (shouldDrawBackgroundInSeparateBuffer)
         context->endLayer();
 }
 
 void BoxPainter::paintFillLayer(const PaintInfo& paintInfo, const Color& c, const FillLayer& fillLayer, const LayoutRect& rect,
     BackgroundBleedAvoidance bleedAvoidance, SkXfermode::Mode op, LayoutObject* backgroundObject, bool skipBaseColor)
 {
-    BoxPainter::paintFillLayerExtended(m_renderBox, paintInfo, c, fillLayer, rect, bleedAvoidance, 0, LayoutSize(), op, backgroundObject, skipBaseColor);
+    BoxPainter::paintFillLayerExtended(m_layoutBox, paintInfo, c, fillLayer, rect, bleedAvoidance, 0, LayoutSize(), op, backgroundObject, skipBaseColor);
 }
 
 void BoxPainter::applyBoxShadowForBackground(GraphicsContext* context, LayoutObject& obj)
 {
     const ShadowList* shadowList = obj.style()->boxShadow();
     ASSERT(shadowList);
     for (size_t i = shadowList->shadows().size(); i--; ) {
         const ShadowData& boxShadow = shadowList->shadows()[i];
         if (boxShadow.style() != Normal)
             continue;
@@ skipping 131 matching lines @@
 
     int bLeft = includeLeftEdge ? obj.borderLeft() : 0;
     int bRight = includeRightEdge ? obj.borderRight() : 0;
     LayoutUnit pLeft = includeLeftEdge ? obj.paddingLeft() : LayoutUnit();
     LayoutUnit pRight = includeRightEdge ? obj.paddingRight() : LayoutUnit();
 
     GraphicsContextStateSaver clipWithScrollingStateSaver(*context, clippedWithLocalScrolling);
     LayoutRect scrolledPaintRect = rect;
     if (clippedWithLocalScrolling) {
         // Clip to the overflow area.
-        RenderBox* thisBox = toRenderBox(&obj);
+        LayoutBox* thisBox = toLayoutBox(&obj);
         context->clip(thisBox->overflowClipRect(rect.location()));
 
         // Adjust the paint rect to reflect a scrolled content box with borders at the ends.
         IntSize offset = thisBox->scrolledContentOffset();
         scrolledPaintRect.move(-offset);
         scrolledPaintRect.setWidth(bLeft + thisBox->scrollWidth() + bRight);
         scrolledPaintRect.setHeight(thisBox->borderTop() + thisBox->scrollHeight() + thisBox->borderBottom());
     }
 
     GraphicsContextStateSaver backgroundClipStateSaver(*context, false);
@@ skipping 37 matching lines @@
         break;
     }
 
     // Paint the color first underneath all images, culled if background image occludes it.
     // FIXME: In the bgLayer->hasFiniteBounds() case, we could improve the culling test
     // by verifying whether the background image covers the entire layout rect.
     if (isBottomLayer) {
         IntRect backgroundRect(pixelSnappedIntRect(scrolledPaintRect));
         bool boxShadowShouldBeAppliedToBackground = obj.boxShadowShouldBeAppliedToBackground(bleedAvoidance, box);
         bool isOpaqueRoot = (isDocumentElementRenderer && !bgColor.hasAlpha()) || isDocumentElementWithOpaqueBackground(obj);
-        if (boxShadowShouldBeAppliedToBackground || !shouldPaintBackgroundImage || !bgLayer.hasOpaqueImage(&obj) || !bgLayer.hasRepeatXY() || (isOpaqueRoot && !toRenderBox(&obj)->size().height()))  {
+        if (boxShadowShouldBeAppliedToBackground || !shouldPaintBackgroundImage || !bgLayer.hasOpaqueImage(&obj) || !bgLayer.hasRepeatXY() || (isOpaqueRoot && !toLayoutBox(&obj)->size().height()))  {
             if (!boxShadowShouldBeAppliedToBackground)
                 backgroundRect.intersect(paintInfo.rect);
 
             GraphicsContextStateSaver shadowStateSaver(*context, boxShadowShouldBeAppliedToBackground);
             if (boxShadowShouldBeAppliedToBackground)
                 BoxPainter::applyBoxShadowForBackground(context, obj);
 
             if (isOpaqueRoot && !skipBaseColor) {
                 paintRootBackgroundColor(obj, paintInfo, rect, bgColor);
             } else if (bgColor.alpha()) {
@@ skipping 34 matching lines @@
 
         // Now draw the text into the mask. We do this by painting using a special paint phase that signals to
         // InlineTextBoxes that they should just add their contents to the clip.
         PaintInfo info(context, maskRect, PaintPhaseTextClip, PaintBehaviorForceBlackText, 0);
         context->setCompositeOperation(SkXfermode::kSrcOver_Mode);
         if (box) {
             RootInlineBox& root = box->root();
             box->paint(info, LayoutPoint(scrolledPaintRect.x() - box->x(), scrolledPaintRect.y() - box->y()), root.lineTop(), root.lineBottom());
         } else {
             // FIXME: this should only have an effect for the line box list within |obj|. Change this to create a LineBoxListPainter directly.
-            LayoutSize localOffset = obj.isBox() ? toRenderBox(&obj)->locationOffset() : LayoutSize();
+            LayoutSize localOffset = obj.isBox() ? toLayoutBox(&obj)->locationOffset() : LayoutSize();
             obj.paint(info, scrolledPaintRect.location() - localOffset);
         }
 
         context->endLayer();
         context->endLayer();
     }
 }
 
 void BoxPainter::paintMask(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
-    if (!paintInfo.shouldPaintWithinRoot(&m_renderBox) || m_renderBox.style()->visibility() != VISIBLE || paintInfo.phase != PaintPhaseMask)
+    if (!paintInfo.shouldPaintWithinRoot(&m_layoutBox) || m_layoutBox.style()->visibility() != VISIBLE || paintInfo.phase != PaintPhaseMask)
         return;
 
-    LayoutRect paintRect = LayoutRect(paintOffset, m_renderBox.size());
+    LayoutRect paintRect = LayoutRect(paintOffset, m_layoutBox.size());
     paintMaskImages(paintInfo, paintRect);
 }
 
 void BoxPainter::paintMaskImages(const PaintInfo& paintInfo, const LayoutRect& paintRect)
 {
     // Figure out if we need to push a transparency layer to render our mask.
     bool pushTransparencyLayer = false;
-    bool compositedMask = m_renderBox.hasLayer() && m_renderBox.layer()->hasCompositedMask();
-    bool flattenCompositingLayers = m_renderBox.view()->frameView() && m_renderBox.view()->frameView()->paintBehavior() & PaintBehaviorFlattenCompositingLayers;
+    bool compositedMask = m_layoutBox.hasLayer() && m_layoutBox.layer()->hasCompositedMask();
+    bool flattenCompositingLayers = m_layoutBox.view()->frameView() && m_layoutBox.view()->frameView()->paintBehavior() & PaintBehaviorFlattenCompositingLayers;
 
     bool allMaskImagesLoaded = true;
 
     SkXfermode::Mode previousCompositeOperation = paintInfo.context->compositeOperation();
 
     if (!compositedMask || flattenCompositingLayers) {
         pushTransparencyLayer = true;
-        StyleImage* maskBoxImage = m_renderBox.style()->maskBoxImage().image();
-        const FillLayer& maskLayers = m_renderBox.style()->maskLayers();
+        StyleImage* maskBoxImage = m_layoutBox.style()->maskBoxImage().image();
+        const FillLayer& maskLayers = m_layoutBox.style()->maskLayers();
 
         // Don't render a masked element until all the mask images have loaded, to prevent a flash of unmasked content.
         if (maskBoxImage)
             allMaskImagesLoaded &= maskBoxImage->isLoaded();
 
         allMaskImagesLoaded &= maskLayers.imagesAreLoaded();
 
         paintInfo.context->setCompositeOperation(SkXfermode::kDstIn_Mode);
         paintInfo.context->beginTransparencyLayer(1);
     }
 
     if (allMaskImagesLoaded) {
-        paintFillLayers(paintInfo, Color::transparent, m_renderBox.style()->maskLayers(), paintRect, BackgroundBleedNone, SkXfermode::kSrcOver_Mode);
-        paintNinePieceImage(m_renderBox, paintInfo.context, paintRect, m_renderBox.styleRef(), m_renderBox.style()->maskBoxImage(), SkXfermode::kSrcOver_Mode);
+        paintFillLayers(paintInfo, Color::transparent, m_layoutBox.style()->maskLayers(), paintRect, BackgroundBleedNone, SkXfermode::kSrcOver_Mode);
+        paintNinePieceImage(m_layoutBox, paintInfo.context, paintRect, m_layoutBox.styleRef(), m_layoutBox.style()->maskBoxImage(), SkXfermode::kSrcOver_Mode);
     }
 
     if (pushTransparencyLayer) {
         paintInfo.context->endLayer();
         paintInfo.context->setCompositeOperation(previousCompositeOperation);
     }
 }
 
 void BoxPainter::paintClippingMask(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
-    if (!paintInfo.shouldPaintWithinRoot(&m_renderBox) || m_renderBox.style()->visibility() != VISIBLE || paintInfo.phase != PaintPhaseClippingMask)
+    if (!paintInfo.shouldPaintWithinRoot(&m_layoutBox) || m_layoutBox.style()->visibility() != VISIBLE || paintInfo.phase != PaintPhaseClippingMask)
         return;
 
-    if (!m_renderBox.layer() || m_renderBox.layer()->compositingState() != PaintsIntoOwnBacking)
+    if (!m_layoutBox.layer() || m_layoutBox.layer()->compositingState() != PaintsIntoOwnBacking)
         return;
 
-    LayoutRect paintRect = LayoutRect(paintOffset, m_renderBox.size());
+    LayoutRect paintRect = LayoutRect(paintOffset, m_layoutBox.size());
     paintInfo.context->fillRect(pixelSnappedIntRect(paintRect), Color::black);
 }
 
 void BoxPainter::paintRootBackgroundColor(LayoutObject& obj, const PaintInfo& paintInfo, const LayoutRect& rect, const Color& bgColor)
 {
     GraphicsContext* context = paintInfo.context;
     if (rect.isEmpty())
         return;
 
     ASSERT(obj.isDocumentElement());
@@ skipping 100 matching lines @@
                 right += obj.paddingRight();
                 top += obj.paddingTop();
                 bottom += obj.paddingBottom();
             }
         }
 
         // The background of the box generated by the root element covers the entire canvas including
         // its margins. Since those were added in already, we have to factor them out when computing
         // the background positioning area.
         if (obj.isDocumentElement()) {
-            positioningAreaSize = pixelSnappedIntSize(toRenderBox(&obj)->size() - LayoutSize(left + right, top + bottom), toRenderBox(&obj)->location());
+            positioningAreaSize = pixelSnappedIntSize(toLayoutBox(&obj)->size() - LayoutSize(left + right, top + bottom), toLayoutBox(&obj)->location());
             left += obj.marginLeft();
             top += obj.marginTop();
         } else {
             positioningAreaSize = pixelSnappedIntSize(paintRect.size() - LayoutSize(left + right, top + bottom), paintRect.location());
         }
     } else {
         geometry.setHasNonLocalGeometry();
 
         IntRect viewportRect = pixelSnappedIntRect(obj.viewRect());
         if (fixedBackgroundPaintsInLocalCoordinates(obj))
@@ skipping 1511 matching lines @@
 
     FloatPoint secondQuad[4];
     secondQuad[0] = quad[0];
     secondQuad[1] = FloatPoint(quad[0].x() - r1 * cx, quad[0].y() - r1 * cy);
     secondQuad[2] = quad[2];
     secondQuad[3] = quad[3];
     graphicsContext->clipPolygon(4, secondQuad, !secondEdgeMatches);
 }
 
 } // namespace blink