Prepare RenderLayerBacking and RenderLayerCompositor for subpixel layout
https://bugs.webkit.org/show_bug.cgi?id=78630
Reviewed by Simon Fraser.
In our transition to subpixel layout in the render tree, we continue to pass RenderLayerBacking
and RenderLayerCompositor integer (pixel) sizes and positions. This patch moves nearly all
methods and members on these two classes back to integers, and applies pixel snapping logic to
LayoutUnits pulled in.
No new tests. No change in behavior.
* rendering/RenderBox.h:
(WebCore::RenderBox::pixelSnappedLayoutOverflowRect): Convenience function for getting pixel
snapped overflow bounds.
* rendering/RenderLayerBacking.cpp:
(WebCore):
(WebCore::RenderLayerBacking::updateCompositedBounds): Switch to integers and pixel snapping the
clipping bounds.
(WebCore::clipBox): Returns a pixel snapped rect.
(WebCore::RenderLayerBacking::updateGraphicsLayerGeometry): Using pixelSnappedLayerCoords. Removing
pixelSnappedIntRect calls to clipBox since this is now an IntRect.
(WebCore::RenderLayerBacking::computeTransformOrigin): Switching to operate on a pixel snapped rect.
(WebCore::RenderLayerBacking::computePerspectiveOrigin): Ditto.
(WebCore::RenderLayerBacking::contentOffsetInCompostingLayer): Returns a size based on m_compositingBounds,
which is now an IntSize.
(WebCore::RenderLayerBacking::contentsBox): Switching to use pixel snapped values from the render tree.
(WebCore::RenderLayerBacking::setContentsNeedDisplayInRect): This now takes in and outputs integers.
(WebCore::RenderLayerBacking::paintIntoLayer): Uses a pixel snapped rect for the dirty rect.
(WebCore::paintScrollbar): Scrollbars are Widgets & painted natively, so they should use integers.
(WebCore::RenderLayerBacking::paintContents): We now properly take in an integer clip rect, as it's
used for the scrollbars.
(WebCore::RenderLayerBacking::startAnimation): Using pixel snapped values for animations and transitions.
(WebCore::RenderLayerBacking::startTransition): Ditto.
(WebCore::RenderLayerBacking::compositedBounds): Composited bounds are now properly stored as integers.
(WebCore::RenderLayerBacking::setCompositedBounds): Ditto.
* rendering/RenderLayerBacking.h:
(RenderLayerBacking):
* rendering/RenderLayerCompositor.cpp:
(WebCore::RenderLayerCompositor::calculateCompositedBounds): Composited bounds are pixel snapped, but
we use LayoutUnits up until we snap and return.
(WebCore::RenderLayerCompositor::addToOverlapMap): Overlap mapping uses our integer positions. Switching
it back to operating on them.
(WebCore::RenderLayerCompositor::addToOverlapMapRecursive): Ditto.
(WebCore::RenderLayerCompositor::overlapsCompositedLayers): Ditto.
(WebCore::RenderLayerCompositor::computeCompositingRequirements): Using integers.
(WebCore::RenderLayerCompositor::frameViewDidChangeLocation): FrameViews are on integer bounds. We now
properly use these as integers.
(WebCore::RenderLayerCompositor::frameViewDidScroll): Ditto.
(WebCore::RenderLayerCompositor::recursiveRepaintLayerRect): Switching to use integers and
pixelSnappedLayerCoords.
(WebCore::RenderLayerCompositor::repaintCompositedLayersAbsoluteRect): Ditto.
(WebCore::RenderLayerCompositor::updateRootLayerPosition): Using integer positions, which are what
the apis used already returned.
(WebCore::RenderLayerCompositor::requiresCompositingForPlugin): Using pixel snapped values.
(WebCore::RenderLayerCompositor::requiresCompositingForFrame): Ditto.
(WebCore::paintScrollbar): Scrollbars should always use integers.
(WebCore::RenderLayerCompositor::paintContents): Switching to use an integer clip rect.
(WebCore::RenderLayerCompositor::ensureRootLayer): Using values from new pixelSnappedLayoutOverflowRect
method on RenderBox to ensure we're using values that are pixel snapped to the proper location.
(WebCore::RenderLayerCompositor::destroyRootLayer): Properly calling scrollbar invalidation methods
with integers.
* rendering/RenderLayerCompositor.h:
(RenderLayerCompositor):
git-svn-id: http://svn.webkit.org/repository/webkit/trunk@107760 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/Source/WebCore/rendering/RenderLayerBacking.cpp b/Source/WebCore/rendering/RenderLayerBacking.cpp
index 638f1eb..6a4a499 100644
--- a/Source/WebCore/rendering/RenderLayerBacking.cpp
+++ b/Source/WebCore/rendering/RenderLayerBacking.cpp
@@ -70,7 +70,7 @@
static bool hasBoxDecorations(const RenderStyle*);
static bool hasBoxDecorationsOrBackground(const RenderObject*);
static bool hasBoxDecorationsOrBackgroundImage(const RenderStyle*);
-static LayoutRect clipBox(RenderBox* renderer);
+static IntRect clipBox(RenderBox* renderer);
static inline bool isAcceleratedCanvas(RenderObject* renderer)
{
@@ -229,7 +229,7 @@
void RenderLayerBacking::updateCompositedBounds()
{
- LayoutRect layerBounds = compositor()->calculateCompositedBounds(m_owningLayer, m_owningLayer);
+ IntRect layerBounds = compositor()->calculateCompositedBounds(m_owningLayer, m_owningLayer);
// Clip to the size of the document or enclosing overflow-scroll layer.
// If this or an ancestor is transformed, we can't currently compute the correct rect to intersect with.
@@ -254,7 +254,7 @@
m_owningLayer->convertToLayerCoords(rootLayer, delta);
clippingBounds.move(-delta.x(), -delta.y());
- layerBounds.intersect(clippingBounds);
+ layerBounds.intersect(pixelSnappedIntRect(clippingBounds));
}
// If the element has a transform-origin that has fixed lengths, and the renderer has zero size,
@@ -371,7 +371,7 @@
return layerConfigChanged;
}
-static LayoutRect clipBox(RenderBox* renderer)
+static IntRect clipBox(RenderBox* renderer)
{
LayoutRect result = PaintInfo::infiniteRect();
if (renderer->hasOverflowClip())
@@ -380,7 +380,7 @@
if (renderer->hasClip())
result.intersect(renderer->clipRect(LayoutPoint(), 0)); // FIXME: Incorrect for CSS regions.
- return result;
+ return pixelSnappedIntRect(result);
}
void RenderLayerBacking::updateGraphicsLayerGeometry()
@@ -426,14 +426,14 @@
IntRect relativeCompositingBounds(localCompositingBounds);
IntPoint delta;
- m_owningLayer->convertToLayerCoords(compAncestor, delta);
+ m_owningLayer->convertToPixelSnappedLayerCoords(compAncestor, delta);
relativeCompositingBounds.moveBy(delta);
- LayoutPoint graphicsLayerParentLocation;
+ IntPoint graphicsLayerParentLocation;
if (compAncestor && compAncestor->backing()->hasClippingLayer()) {
// If the compositing ancestor has a layer to clip children, we parent in that, and therefore
// position relative to it.
- IntRect clippingBox = pixelSnappedIntRect(clipBox(toRenderBox(compAncestor->renderer())));
+ IntRect clippingBox = clipBox(toRenderBox(compAncestor->renderer()));
graphicsLayerParentLocation = clippingBox.location();
} else if (compAncestor)
graphicsLayerParentLocation = ancestorCompositingBounds.location();
@@ -472,10 +472,10 @@
// If we have a layer that clips children, position it.
IntRect clippingBox;
if (m_clippingLayer) {
- clippingBox = pixelSnappedIntRect(clipBox(toRenderBox(renderer())));
+ clippingBox = clipBox(toRenderBox(renderer()));
m_clippingLayer->setPosition(FloatPoint() + (clippingBox.location() - localCompositingBounds.location()));
m_clippingLayer->setSize(clippingBox.size());
- m_clippingLayer->setOffsetFromRenderer(clippingBox.location() - LayoutPoint());
+ m_clippingLayer->setOffsetFromRenderer(clippingBox.location() - IntPoint());
}
if (m_maskLayer) {
@@ -548,7 +548,7 @@
reflectionBacking->graphicsLayer()->setReplicatedLayerPosition(FloatPoint() + (layerBounds.location() - reflectionLayerBounds.location()));
}
- m_graphicsLayer->setContentsRect(pixelSnappedIntRect(contentsBox()));
+ m_graphicsLayer->setContentsRect(contentsBox());
updateDrawsContent();
updateAfterWidgetResize();
}
@@ -1002,7 +1002,7 @@
image->startAnimation();
}
-FloatPoint3D RenderLayerBacking::computeTransformOrigin(const LayoutRect& borderBox) const
+FloatPoint3D RenderLayerBacking::computeTransformOrigin(const IntRect& borderBox) const
{
RenderStyle* style = renderer()->style();
@@ -1014,7 +1014,7 @@
return origin;
}
-FloatPoint RenderLayerBacking::computePerspectiveOrigin(const LayoutRect& borderBox) const
+FloatPoint RenderLayerBacking::computePerspectiveOrigin(const IntRect& borderBox) const
{
RenderStyle* style = renderer()->style();
@@ -1029,26 +1029,26 @@
}
// Return the offset from the top-left of this compositing layer at which the renderer's contents are painted.
-LayoutSize RenderLayerBacking::contentOffsetInCompostingLayer() const
+IntSize RenderLayerBacking::contentOffsetInCompostingLayer() const
{
- return LayoutSize(-m_compositedBounds.x(), -m_compositedBounds.y());
+ return IntSize(-m_compositedBounds.x(), -m_compositedBounds.y());
}
-LayoutRect RenderLayerBacking::contentsBox() const
+IntRect RenderLayerBacking::contentsBox() const
{
if (!renderer()->isBox())
- return LayoutRect();
+ return IntRect();
- LayoutRect contentsRect;
+ IntRect contentsRect;
#if ENABLE(VIDEO)
if (renderer()->isVideo()) {
RenderVideo* videoRenderer = toRenderVideo(renderer());
contentsRect = videoRenderer->videoBox();
} else
#endif
- contentsRect = toRenderBox(renderer())->contentBoxRect();
+ contentsRect = pixelSnappedIntRect(toRenderBox(renderer())->contentBoxRect());
- LayoutSize contentOffset = contentOffsetInCompostingLayer();
+ IntSize contentOffset = contentOffsetInCompostingLayer();
contentsRect.move(contentOffset);
return contentsRect;
}
@@ -1077,29 +1077,29 @@
}
// r is in the coordinate space of the layer's render object
-void RenderLayerBacking::setContentsNeedDisplayInRect(const LayoutRect& r)
+void RenderLayerBacking::setContentsNeedDisplayInRect(const IntRect& r)
{
if (m_graphicsLayer && m_graphicsLayer->drawsContent()) {
- LayoutRect layerDirtyRect = r;
+ IntRect layerDirtyRect = r;
layerDirtyRect.move(-m_graphicsLayer->offsetFromRenderer());
m_graphicsLayer->setNeedsDisplayInRect(layerDirtyRect);
}
if (m_foregroundLayer && m_foregroundLayer->drawsContent()) {
- LayoutRect layerDirtyRect = r;
+ IntRect layerDirtyRect = r;
layerDirtyRect.move(-m_foregroundLayer->offsetFromRenderer());
m_foregroundLayer->setNeedsDisplayInRect(layerDirtyRect);
}
if (m_maskLayer && m_maskLayer->drawsContent()) {
- LayoutRect layerDirtyRect = r;
+ IntRect layerDirtyRect = r;
layerDirtyRect.move(-m_maskLayer->offsetFromRenderer());
m_maskLayer->setNeedsDisplayInRect(layerDirtyRect);
}
}
void RenderLayerBacking::paintIntoLayer(RenderLayer* rootLayer, GraphicsContext* context,
- const LayoutRect& paintDirtyRect, // In the coords of rootLayer.
+ const IntRect& paintDirtyRect, // In the coords of rootLayer.
PaintBehavior paintBehavior, GraphicsLayerPaintingPhase paintingPhase,
RenderObject* paintingRoot)
{
@@ -1124,28 +1124,28 @@
ASSERT(!m_owningLayer->m_usedTransparency);
}
-static void paintScrollbar(Scrollbar* scrollbar, GraphicsContext& context, const LayoutRect& clip)
+static void paintScrollbar(Scrollbar* scrollbar, GraphicsContext& context, const IntRect& clip)
{
if (!scrollbar)
return;
context.save();
- const LayoutRect& scrollbarRect = scrollbar->frameRect();
+ const IntRect& scrollbarRect = scrollbar->frameRect();
context.translate(-scrollbarRect.x(), -scrollbarRect.y());
- LayoutRect transformedClip = clip;
+ IntRect transformedClip = clip;
transformedClip.moveBy(scrollbarRect.location());
- scrollbar->paint(&context, pixelSnappedIntRect(transformedClip));
+ scrollbar->paint(&context, transformedClip);
context.restore();
}
// Up-call from compositing layer drawing callback.
-void RenderLayerBacking::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& context, GraphicsLayerPaintingPhase paintingPhase, const LayoutRect& clip)
+void RenderLayerBacking::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& context, GraphicsLayerPaintingPhase paintingPhase, const IntRect& clip)
{
if (graphicsLayer == m_graphicsLayer.get() || graphicsLayer == m_foregroundLayer.get() || graphicsLayer == m_maskLayer.get()) {
InspectorInstrumentationCookie cookie = InspectorInstrumentation::willPaint(m_owningLayer->renderer()->frame(), clip);
// The dirtyRect is in the coords of the painting root.
- LayoutRect dirtyRect = compositedBounds();
+ IntRect dirtyRect = compositedBounds();
dirtyRect.intersect(clip);
// We have to use the same root as for hit testing, because both methods can compute and cache clipRects.
@@ -1157,13 +1157,13 @@
} else if (graphicsLayer == layerForVerticalScrollbar()) {
paintScrollbar(m_owningLayer->verticalScrollbar(), context, clip);
} else if (graphicsLayer == layerForScrollCorner()) {
- const LayoutRect& scrollCornerAndResizer = m_owningLayer->scrollCornerAndResizerRect();
+ const IntRect& scrollCornerAndResizer = m_owningLayer->scrollCornerAndResizerRect();
context.save();
context.translate(-scrollCornerAndResizer.x(), -scrollCornerAndResizer.y());
- LayoutRect transformedClip = clip;
- transformedClip.moveBy(roundedIntPoint(scrollCornerAndResizer.location()));
- m_owningLayer->paintScrollCorner(&context, LayoutPoint(), transformedClip);
- m_owningLayer->paintResizer(&context, LayoutPoint(), transformedClip);
+ IntRect transformedClip = clip;
+ transformedClip.moveBy(scrollCornerAndResizer.location());
+ m_owningLayer->paintScrollCorner(&context, IntPoint(), transformedClip);
+ m_owningLayer->paintResizer(&context, IntPoint(), transformedClip);
context.restore();
}
}
@@ -1243,18 +1243,18 @@
bool didAnimateFilter = false;
#endif
- if (hasTransform && m_graphicsLayer->addAnimation(transformVector, toRenderBox(renderer())->borderBoxRect().size(), anim, keyframes.animationName(), timeOffset)) {
+ if (hasTransform && m_graphicsLayer->addAnimation(transformVector, pixelSnappedIntRect(toRenderBox(renderer())->borderBoxRect()).size(), anim, keyframes.animationName(), timeOffset)) {
didAnimateTransform = true;
compositor()->didStartAcceleratedAnimation(CSSPropertyWebkitTransform);
}
- if (hasOpacity && m_graphicsLayer->addAnimation(opacityVector, LayoutSize(), anim, keyframes.animationName(), timeOffset)) {
+ if (hasOpacity && m_graphicsLayer->addAnimation(opacityVector, IntSize(), anim, keyframes.animationName(), timeOffset)) {
didAnimateOpacity = true;
compositor()->didStartAcceleratedAnimation(CSSPropertyOpacity);
}
#if ENABLE(CSS_FILTERS)
- if (hasFilter && m_graphicsLayer->addAnimation(filterVector, LayoutSize(), anim, keyframes.animationName(), timeOffset)) {
+ if (hasFilter && m_graphicsLayer->addAnimation(filterVector, IntSize(), anim, keyframes.animationName(), timeOffset)) {
didAnimateFilter = true;
compositor()->didStartAcceleratedAnimation(CSSPropertyWebkitFilter);
}
@@ -1294,7 +1294,7 @@
opacityVector.insert(new FloatAnimationValue(0, compositingOpacity(fromStyle->opacity())));
opacityVector.insert(new FloatAnimationValue(1, compositingOpacity(toStyle->opacity())));
// The boxSize param is only used for transform animations (which can only run on RenderBoxes), so we pass an empty size here.
- if (m_graphicsLayer->addAnimation(opacityVector, LayoutSize(), opacityAnim, GraphicsLayer::animationNameForTransition(AnimatedPropertyOpacity), timeOffset)) {
+ if (m_graphicsLayer->addAnimation(opacityVector, IntSize(), opacityAnim, GraphicsLayer::animationNameForTransition(AnimatedPropertyOpacity), timeOffset)) {
// To ensure that the correct opacity is visible when the animation ends, also set the final opacity.
updateLayerOpacity(toStyle);
didAnimateOpacity = true;
@@ -1308,7 +1308,7 @@
KeyframeValueList transformVector(AnimatedPropertyWebkitTransform);
transformVector.insert(new TransformAnimationValue(0, &fromStyle->transform()));
transformVector.insert(new TransformAnimationValue(1, &toStyle->transform()));
- if (m_graphicsLayer->addAnimation(transformVector, toRenderBox(renderer())->borderBoxRect().size(), transformAnim, GraphicsLayer::animationNameForTransition(AnimatedPropertyWebkitTransform), timeOffset)) {
+ if (m_graphicsLayer->addAnimation(transformVector, pixelSnappedIntRect(toRenderBox(renderer())->borderBoxRect()).size(), transformAnim, GraphicsLayer::animationNameForTransition(AnimatedPropertyWebkitTransform), timeOffset)) {
// To ensure that the correct transform is visible when the animation ends, also set the final transform.
updateLayerTransform(toStyle);
didAnimateTransform = true;
@@ -1323,7 +1323,7 @@
KeyframeValueList filterVector(AnimatedPropertyWebkitFilter);
filterVector.insert(new FilterAnimationValue(0, &fromStyle->filter()));
filterVector.insert(new FilterAnimationValue(1, &toStyle->filter()));
- if (m_graphicsLayer->addAnimation(filterVector, LayoutSize(), filterAnim, GraphicsLayer::animationNameForTransition(AnimatedPropertyWebkitFilter), timeOffset)) {
+ if (m_graphicsLayer->addAnimation(filterVector, IntSize(), filterAnim, GraphicsLayer::animationNameForTransition(AnimatedPropertyWebkitFilter), timeOffset)) {
// To ensure that the correct filter is visible when the animation ends, also set the final filter.
updateLayerFilters(toStyle);
didAnimateFilter = true;
@@ -1386,12 +1386,12 @@
m_graphicsLayer->resumeAnimations();
}
-LayoutRect RenderLayerBacking::compositedBounds() const
+IntRect RenderLayerBacking::compositedBounds() const
{
return m_compositedBounds;
}
-void RenderLayerBacking::setCompositedBounds(const LayoutRect& bounds)
+void RenderLayerBacking::setCompositedBounds(const IntRect& bounds)
{
m_compositedBounds = bounds;
