void RenderLayerClipper::calculateRects(const ClipRectsContext& clipRectsContext, const LayoutRect& paintDirtyRect, LayoutRect& layerBounds,
ClipRect& backgroundRect, ClipRect& foregroundRect, ClipRect& outlineRect, const LayoutPoint* offsetFromRoot) const
{
if (clipRectsContext.rootLayer != m_renderer->layer() && m_renderer->layer()->parent()) {
backgroundRect = backgroundClipRect(clipRectsContext);
backgroundRect.move(roundedIntSize(clipRectsContext.subPixelAccumulation));
backgroundRect.intersect(paintDirtyRect);
} else {
backgroundRect = paintDirtyRect;
}
foregroundRect = backgroundRect;
outlineRect = backgroundRect;
LayoutPoint offset;
if (offsetFromRoot)
offset = *offsetFromRoot;
else
m_renderer->layer()->convertToLayerCoords(clipRectsContext.rootLayer, offset);
layerBounds = LayoutRect(offset, m_renderer->layer()->size());
// Update the clip rects that will be passed to child layers.
if (m_renderer->hasOverflowClip()) {
// This layer establishes a clip of some kind.
if (m_renderer->layer() != clipRectsContext.rootLayer || clipRectsContext.respectOverflowClip == RespectOverflowClip) {
foregroundRect.intersect(toRenderBox(m_renderer)->overflowClipRect(offset, clipRectsContext.overlayScrollbarSizeRelevancy));
if (m_renderer->style()->hasBorderRadius())
foregroundRect.setHasRadius(true);
}
// If we establish an overflow clip at all, then go ahead and make sure our background
// rect is intersected with our layer's bounds including our visual overflow,
// since any visual overflow like box-shadow or border-outset is not clipped by overflow:auto/hidden.
if (toRenderBox(m_renderer)->hasVisualOverflow()) {
// FIXME: Perhaps we should be propagating the borderbox as the clip rect for children, even though
// we may need to inflate our clip specifically for shadows or outsets.
// FIXME: Does not do the right thing with CSS regions yet, since we don't yet factor in the
// individual region boxes as overflow.
LayoutRect layerBoundsWithVisualOverflow = toRenderBox(m_renderer)->visualOverflowRect();
toRenderBox(m_renderer)->flipForWritingMode(layerBoundsWithVisualOverflow); // Layers are in physical coordinates, so the overflow has to be flipped.
layerBoundsWithVisualOverflow.moveBy(offset);
if (m_renderer->layer() != clipRectsContext.rootLayer || clipRectsContext.respectOverflowClip == RespectOverflowClip)
backgroundRect.intersect(layerBoundsWithVisualOverflow);
} else {
LayoutRect bounds = toRenderBox(m_renderer)->borderBoxRect();
bounds.moveBy(offset);
if (m_renderer->layer() != clipRectsContext.rootLayer || clipRectsContext.respectOverflowClip == RespectOverflowClip)
backgroundRect.intersect(bounds);
}
}
// CSS clip (different than clipping due to overflow) can clip to any box, even if it falls outside of the border box.
if (m_renderer->hasClip()) {
// Clip applies to *us* as well, so go ahead and update the damageRect.
LayoutRect newPosClip = toRenderBox(m_renderer)->clipRect(offset);
backgroundRect.intersect(newPosClip);
foregroundRect.intersect(newPosClip);
outlineRect.intersect(newPosClip);
}
}
void PaintLayerClipper::calculateRects(const ClipRectsContext& context, const LayoutRect& paintDirtyRect, LayoutRect& layerBounds,
ClipRect& backgroundRect, ClipRect& foregroundRect, const LayoutPoint* offsetFromRoot) const
{
bool isClippingRoot = m_layoutObject.layer() == context.rootLayer;
if (!isClippingRoot && m_layoutObject.layer()->parent()) {
backgroundRect = backgroundClipRect(context);
backgroundRect.move(context.subPixelAccumulation);
backgroundRect.intersect(paintDirtyRect);
} else {
backgroundRect = paintDirtyRect;
}
foregroundRect = backgroundRect;
LayoutPoint offset;
if (offsetFromRoot)
offset = *offsetFromRoot;
else
m_layoutObject.layer()->convertToLayerCoords(context.rootLayer, offset);
layerBounds = LayoutRect(offset, LayoutSize(m_layoutObject.layer()->size()));
// Update the clip rects that will be passed to child layers.
if (m_layoutObject.hasOverflowClip() && shouldRespectOverflowClip(context)) {
foregroundRect.intersect(toLayoutBox(m_layoutObject).overflowClipRect(offset, context.scrollbarRelevancy));
if (m_layoutObject.style()->hasBorderRadius())
foregroundRect.setHasRadius(true);
// FIXME: Does not do the right thing with columns yet, since we don't yet factor in the
// individual column boxes as overflow.
// The LayoutView is special since its overflow clipping rect may be larger than its box rect (crbug.com/492871).
LayoutRect layerBoundsWithVisualOverflow = m_layoutObject.isLayoutView() ? toLayoutView(m_layoutObject).viewRect() : toLayoutBox(m_layoutObject).visualOverflowRect();
toLayoutBox(m_layoutObject).flipForWritingMode(layerBoundsWithVisualOverflow); // PaintLayer are in physical coordinates, so the overflow has to be flipped.
layerBoundsWithVisualOverflow.moveBy(offset);
backgroundRect.intersect(layerBoundsWithVisualOverflow);
}
// CSS clip (different than clipping due to overflow) can clip to any box, even if it falls outside of the border box.
if (m_layoutObject.hasClip()) {
// Clip applies to *us* as well, so go ahead and update the damageRect.
LayoutRect newPosClip = toLayoutBox(m_layoutObject).clipRect(offset);
backgroundRect.intersect(newPosClip);
backgroundRect.setIsClippedByClipCss();
foregroundRect.intersect(newPosClip);
foregroundRect.setIsClippedByClipCss();
}
}
void RenderLayerClipper::calculateRects(const ClipRectsContext& context, const LayoutRect& paintDirtyRect, LayoutRect& layerBounds,
ClipRect& backgroundRect, const LayoutPoint* offsetFromRoot) const
{
bool isClippingRoot = m_renderer.layer() == context.rootLayer;
if (!isClippingRoot && m_renderer.layer()->parent()) {
backgroundRect = backgroundClipRect(context);
backgroundRect.move(roundedIntSize(context.subPixelAccumulation));
backgroundRect.intersect(paintDirtyRect);
} else {
backgroundRect = paintDirtyRect;
}
LayoutPoint offset;
if (offsetFromRoot)
offset = *offsetFromRoot;
else
m_renderer.layer()->convertToLayerCoords(context.rootLayer, offset);
layerBounds = LayoutRect(offset, m_renderer.layer()->size());
// Update the clip rects that will be passed to child layers.
if (m_renderer.hasOverflowClip()) {
// If we establish an overflow clip at all, then go ahead and make sure our background
// rect is intersected with our layer's bounds including our visual overflow,
// since any visual overflow like box-shadow or border-outset is not clipped by overflow:auto/hidden.
if (m_renderer.hasVisualOverflow()) {
// FIXME: Perhaps we should be propagating the borderbox as the clip rect for children, even though
// we may need to inflate our clip specifically for shadows or outsets.
// FIXME: Does not do the right thing with CSS regions yet, since we don't yet factor in the
// individual region boxes as overflow.
LayoutRect layerBoundsWithVisualOverflow = m_renderer.visualOverflowRect();
layerBoundsWithVisualOverflow.moveBy(offset);
backgroundRect.intersect(layerBoundsWithVisualOverflow);
} else {
LayoutRect bounds = m_renderer.borderBoxRect();
bounds.moveBy(offset);
backgroundRect.intersect(bounds);
}
}
// CSS clip (different than clipping due to overflow) can clip to any box, even if it falls outside of the border box.
if (m_renderer.hasClip()) {
// Clip applies to *us* as well, so go ahead and update the damageRect.
LayoutRect newPosClip = m_renderer.clipRect(offset);
backgroundRect.intersect(newPosClip);
}
}
