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/ChangeLog b/Source/WebCore/ChangeLog
index f1e408d..d4f618f 100644
--- a/Source/WebCore/ChangeLog
+++ b/Source/WebCore/ChangeLog
@@ -1,3 +1,70 @@
+2012-02-14 Levi Weintraub <leviw@chromium.org>
+
+ 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):
+
2012-02-14 Anders Carlsson <andersca@apple.com>
Swipe gestures don't work if main frame has a horizontal scrollbar
diff --git a/Source/WebCore/rendering/RenderBox.h b/Source/WebCore/rendering/RenderBox.h
index f9b852c..ee26382 100644
--- a/Source/WebCore/rendering/RenderBox.h
+++ b/Source/WebCore/rendering/RenderBox.h
@@ -151,6 +151,7 @@
// respectively are flipped when compared to their physical counterparts. For example minX is on the left in vertical-lr,
// but it is on the right in vertical-rl.
LayoutRect layoutOverflowRect() const { return m_overflow ? m_overflow->layoutOverflowRect() : clientBoxRect(); }
+ IntRect pixelSnappedLayoutOverflowRect() const { return pixelSnappedIntRect(layoutOverflowRect()); }
LayoutUnit minYLayoutOverflow() const { return m_overflow? m_overflow->minYLayoutOverflow() : borderTop(); }
LayoutUnit maxYLayoutOverflow() const { return m_overflow ? m_overflow->maxYLayoutOverflow() : borderTop() + clientHeight(); }
LayoutUnit minXLayoutOverflow() const { return m_overflow ? m_overflow->minXLayoutOverflow() : borderLeft(); }
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;
diff --git a/Source/WebCore/rendering/RenderLayerBacking.h b/Source/WebCore/rendering/RenderLayerBacking.h
index b2d481c..e1fafc0 100644
--- a/Source/WebCore/rendering/RenderLayerBacking.h
+++ b/Source/WebCore/rendering/RenderLayerBacking.h
@@ -99,7 +99,7 @@
void setContentsNeedDisplay();
// r is in the coordinate space of the layer's render object
- void setContentsNeedDisplayInRect(const LayoutRect&);
+ void setContentsNeedDisplayInRect(const IntRect&);
// Notification from the renderer that its content changed.
void contentChanged(RenderLayer::ContentChangeType);
@@ -116,8 +116,8 @@
void suspendAnimations(double time = 0);
void resumeAnimations();
- LayoutRect compositedBounds() const;
- void setCompositedBounds(const LayoutRect&);
+ IntRect compositedBounds() const;
+ void setCompositedBounds(const IntRect&);
void updateCompositedBounds();
void updateAfterWidgetResize();
@@ -127,7 +127,7 @@
virtual void notifyAnimationStarted(const GraphicsLayer*, double startTime);
virtual void notifySyncRequired(const GraphicsLayer*);
- virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const LayoutRect& clip);
+ virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const IntRect& clip);
virtual float deviceScaleFactor() const;
virtual float pageScaleFactor() const;
@@ -136,7 +136,7 @@
virtual bool showDebugBorders(const GraphicsLayer*) const;
virtual bool showRepaintCounter(const GraphicsLayer*) const;
- LayoutRect contentsBox() const;
+ IntRect contentsBox() const;
// For informative purposes only.
CompositingLayerType compositingLayerType() const;
@@ -169,11 +169,11 @@
GraphicsLayerPaintingPhase paintingPhaseForPrimaryLayer() const;
- LayoutSize contentOffsetInCompostingLayer() const;
+ IntSize contentOffsetInCompostingLayer() const;
// Result is transform origin in pixels.
- FloatPoint3D computeTransformOrigin(const LayoutRect& borderBox) const;
+ FloatPoint3D computeTransformOrigin(const IntRect& borderBox) const;
// Result is perspective origin in pixels.
- FloatPoint computePerspectiveOrigin(const LayoutRect& borderBox) const;
+ FloatPoint computePerspectiveOrigin(const IntRect& borderBox) const;
void updateLayerOpacity(const RenderStyle*);
void updateLayerTransform(const RenderStyle*);
@@ -200,7 +200,7 @@
bool containsNonEmptyRenderers() const;
bool hasVisibleNonCompositingDescendantLayers() const;
- void paintIntoLayer(RenderLayer* rootLayer, GraphicsContext*, const LayoutRect& paintDirtyRect, PaintBehavior, GraphicsLayerPaintingPhase, RenderObject* paintingRoot);
+ void paintIntoLayer(RenderLayer* rootLayer, GraphicsContext*, const IntRect& paintDirtyRect, PaintBehavior, GraphicsLayerPaintingPhase, RenderObject* paintingRoot);
static int graphicsLayerToCSSProperty(AnimatedPropertyID);
static AnimatedPropertyID cssToGraphicsLayerProperty(int);
@@ -221,7 +221,7 @@
OwnPtr<GraphicsLayer> m_layerForVerticalScrollbar;
OwnPtr<GraphicsLayer> m_layerForScrollCorner;
- LayoutRect m_compositedBounds;
+ IntRect m_compositedBounds;
bool m_artificiallyInflatedBounds; // bounds had to be made non-zero to make transform-origin work
bool m_isMainFrameRenderViewLayer;
diff --git a/Source/WebCore/rendering/RenderLayerCompositor.cpp b/Source/WebCore/rendering/RenderLayerCompositor.cpp
index ecbe44f..f4f9da7 100644
--- a/Source/WebCore/rendering/RenderLayerCompositor.cpp
+++ b/Source/WebCore/rendering/RenderLayerCompositor.cpp
@@ -456,10 +456,10 @@
// The bounds of the GraphicsLayer created for a compositing layer is the union of the bounds of all the descendant
// RenderLayers that are rendered by the composited RenderLayer.
-LayoutRect RenderLayerCompositor::calculateCompositedBounds(const RenderLayer* layer, const RenderLayer* ancestorLayer)
+IntRect RenderLayerCompositor::calculateCompositedBounds(const RenderLayer* layer, const RenderLayer* ancestorLayer)
{
if (!canBeComposited(layer))
- return LayoutRect();
+ return IntRect();
LayoutRect boundingBoxRect = layer->localBoundingBox();
if (layer->renderer()->isRoot()) {
@@ -467,8 +467,8 @@
// then it has to be big enough to cover the viewport in order to display the background. This is akin
// to the code in RenderBox::paintRootBoxFillLayers().
if (m_renderView->frameView()) {
- int rw = m_renderView->frameView()->contentsWidth();
- int rh = m_renderView->frameView()->contentsHeight();
+ LayoutUnit rw = m_renderView->frameView()->contentsWidth();
+ LayoutUnit rh = m_renderView->frameView()->contentsHeight();
boundingBoxRect.setWidth(max(boundingBoxRect.width(), rw - boundingBoxRect.x()));
boundingBoxRect.setHeight(max(boundingBoxRect.height(), rh - boundingBoxRect.y()));
@@ -582,7 +582,7 @@
return 0;
}
-void RenderLayerCompositor::addToOverlapMap(OverlapMap& overlapMap, RenderLayer* layer, LayoutRect& layerBounds, bool& boundsComputed)
+void RenderLayerCompositor::addToOverlapMap(OverlapMap& overlapMap, RenderLayer* layer, IntRect& layerBounds, bool& boundsComputed)
{
if (layer->isRootLayer())
return;
@@ -591,11 +591,11 @@
layerBounds = layer->renderer()->localToAbsoluteQuad(FloatRect(layer->localBoundingBox())).enclosingBoundingBox();
// Empty rects never intersect, but we need them to for the purposes of overlap testing.
if (layerBounds.isEmpty())
- layerBounds.setSize(LayoutSize(1, 1));
+ layerBounds.setSize(IntSize(1, 1));
boundsComputed = true;
}
- LayoutRect clipRect = layer->backgroundClipRect(rootRenderLayer(), 0, true).rect(); // FIXME: Incorrect for CSS regions.
+ IntRect clipRect = pixelSnappedIntRect(layer->backgroundClipRect(rootRenderLayer(), 0, true).rect()); // FIXME: Incorrect for CSS regions.
clipRect.scale(pageScaleFactor());
clipRect.intersect(layerBounds);
overlapMap.add(layer, clipRect);
@@ -606,7 +606,7 @@
if (!canBeComposited(layer) || overlapMap.contains(layer))
return;
- LayoutRect bounds;
+ IntRect bounds;
bool haveComputedBounds = false;
addToOverlapMap(overlapMap, layer, bounds, haveComputedBounds);
@@ -640,11 +640,11 @@
}
}
-bool RenderLayerCompositor::overlapsCompositedLayers(OverlapMap& overlapMap, const LayoutRect& layerBounds)
+bool RenderLayerCompositor::overlapsCompositedLayers(OverlapMap& overlapMap, const IntRect& layerBounds)
{
RenderLayerCompositor::OverlapMap::const_iterator end = overlapMap.end();
for (RenderLayerCompositor::OverlapMap::const_iterator it = overlapMap.begin(); it != end; ++it) {
- const LayoutRect& bounds = it->second;
+ const IntRect& bounds = it->second;
if (layerBounds.intersects(bounds))
return true;
}
@@ -673,13 +673,13 @@
bool mustOverlapCompositedLayers = compositingState.m_subtreeIsCompositing;
bool haveComputedBounds = false;
- LayoutRect absBounds;
+ IntRect absBounds;
if (overlapMap && !overlapMap->isEmpty()) {
// If we're testing for overlap, we only need to composite if we overlap something that is already composited.
absBounds = layer->renderer()->localToAbsoluteQuad(FloatRect(layer->localBoundingBox())).enclosingBoundingBox();
// Empty rects never intersect, but we need them to for the purposes of overlap testing.
if (absBounds.isEmpty())
- absBounds.setSize(LayoutSize(1, 1));
+ absBounds.setSize(IntSize(1, 1));
haveComputedBounds = true;
mustOverlapCompositedLayers = overlapsCompositedLayers(*overlapMap, absBounds);
}
@@ -953,7 +953,7 @@
}
}
-void RenderLayerCompositor::frameViewDidChangeLocation(const LayoutPoint& contentsOffset)
+void RenderLayerCompositor::frameViewDidChangeLocation(const IntPoint& contentsOffset)
{
if (m_overflowControlsHostLayer)
m_overflowControlsHostLayer->setPosition(contentsOffset);
@@ -978,7 +978,7 @@
void RenderLayerCompositor::frameViewDidScroll()
{
FrameView* frameView = m_renderView->frameView();
- LayoutPoint scrollPosition = frameView->scrollPosition();
+ IntPoint scrollPosition = frameView->scrollPosition();
if (RenderLayerBacking* backing = rootRenderLayer()->backing())
backing->graphicsLayer()->visibleRectChanged();
@@ -1137,12 +1137,12 @@
}
-void RenderLayerCompositor::repaintCompositedLayersAbsoluteRect(const LayoutRect& absRect)
+void RenderLayerCompositor::repaintCompositedLayersAbsoluteRect(const IntRect& absRect)
{
recursiveRepaintLayerRect(rootRenderLayer(), absRect);
}
-void RenderLayerCompositor::recursiveRepaintLayerRect(RenderLayer* layer, const LayoutRect& rect)
+void RenderLayerCompositor::recursiveRepaintLayerRect(RenderLayer* layer, const IntRect& rect)
{
// FIXME: This method does not work correctly with transforms.
if (layer->isComposited())
@@ -1153,8 +1153,8 @@
size_t listSize = negZOrderList->size();
for (size_t i = 0; i < listSize; ++i) {
RenderLayer* curLayer = negZOrderList->at(i);
- LayoutRect childRect(rect);
- curLayer->convertToLayerCoords(layer, childRect);
+ IntRect childRect(rect);
+ curLayer->convertToPixelSnappedLayerCoords(layer, childRect);
recursiveRepaintLayerRect(curLayer, childRect);
}
}
@@ -1163,8 +1163,8 @@
size_t listSize = posZOrderList->size();
for (size_t i = 0; i < listSize; ++i) {
RenderLayer* curLayer = posZOrderList->at(i);
- LayoutRect childRect(rect);
- curLayer->convertToLayerCoords(layer, childRect);
+ IntRect childRect(rect);
+ curLayer->convertToPixelSnappedLayerCoords(layer, childRect);
recursiveRepaintLayerRect(curLayer, childRect);
}
}
@@ -1173,8 +1173,8 @@
size_t listSize = normalFlowList->size();
for (size_t i = 0; i < listSize; ++i) {
RenderLayer* curLayer = normalFlowList->at(i);
- LayoutRect childRect(rect);
- curLayer->convertToLayerCoords(layer, childRect);
+ IntRect childRect(rect);
+ curLayer->convertToPixelSnappedLayerCoords(layer, childRect);
recursiveRepaintLayerRect(curLayer, childRect);
}
}
@@ -1234,7 +1234,7 @@
void RenderLayerCompositor::updateRootLayerPosition()
{
if (m_rootContentLayer) {
- const LayoutRect& documentRect = m_renderView->documentRect();
+ const IntRect& documentRect = m_renderView->documentRect();
m_rootContentLayer->setSize(documentRect.size());
m_rootContentLayer->setPosition(documentRect.location());
}
@@ -1474,7 +1474,7 @@
return pluginRenderer->hasLayer() && pluginRenderer->layer()->isComposited();
// Don't go into compositing mode if height or width are zero, or size is 1x1.
- LayoutRect contentBox = pluginRenderer->contentBoxRect();
+ IntRect contentBox = pixelSnappedIntRect(pluginRenderer->contentBoxRect());
return contentBox.height() * contentBox.width() > 1;
}
@@ -1499,7 +1499,7 @@
return frameRenderer->hasLayer() && frameRenderer->layer()->isComposited();
// Don't go into compositing mode if height or width are zero.
- LayoutRect contentBox = frameRenderer->contentBoxRect();
+ IntRect contentBox = pixelSnappedIntRect(frameRenderer->contentBoxRect());
return contentBox.height() * contentBox.width() > 0;
}
@@ -1608,32 +1608,32 @@
|| attachment == RootLayerAttachedViaEnclosingFrame; // a composited frame on Mac
}
-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, transformedClip);
context.restore();
}
-void RenderLayerCompositor::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& context, GraphicsLayerPaintingPhase, const LayoutRect& clip)
+void RenderLayerCompositor::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& context, GraphicsLayerPaintingPhase, const IntRect& clip)
{
if (graphicsLayer == layerForHorizontalScrollbar())
paintScrollbar(m_renderView->frameView()->horizontalScrollbar(), context, clip);
else if (graphicsLayer == layerForVerticalScrollbar())
paintScrollbar(m_renderView->frameView()->verticalScrollbar(), context, clip);
else if (graphicsLayer == layerForScrollCorner()) {
- const LayoutRect& scrollCorner = m_renderView->frameView()->scrollCornerRect();
+ const IntRect& scrollCorner = m_renderView->frameView()->scrollCornerRect();
context.save();
context.translate(-scrollCorner.x(), -scrollCorner.y());
- LayoutRect transformedClip = clip;
- transformedClip.moveBy(roundedIntPoint(scrollCorner.location()));
+ IntRect transformedClip = clip;
+ transformedClip.moveBy(scrollCorner.location());
m_renderView->frameView()->paintScrollCorner(&context, transformedClip);
context.restore();
#if PLATFORM(CHROMIUM) && ENABLE(RUBBER_BANDING)
@@ -1898,7 +1898,8 @@
#ifndef NDEBUG
m_rootContentLayer->setName("content root");
#endif
- m_rootContentLayer->setSize(FloatSize(m_renderView->maxXLayoutOverflow(), m_renderView->maxYLayoutOverflow()));
+ IntRect overflowRect = m_renderView->pixelSnappedLayoutOverflowRect();
+ m_rootContentLayer->setSize(FloatSize(overflowRect.maxX(), overflowRect.maxY()));
m_rootContentLayer->setPosition(FloatPoint());
// Need to clip to prevent transformed content showing outside this frame
@@ -1974,14 +1975,14 @@
m_layerForHorizontalScrollbar->removeFromParent();
m_layerForHorizontalScrollbar = nullptr;
if (Scrollbar* horizontalScrollbar = m_renderView->frameView()->verticalScrollbar())
- m_renderView->frameView()->invalidateScrollbar(horizontalScrollbar, LayoutRect(LayoutPoint(0, 0), horizontalScrollbar->frameRect().size()));
+ m_renderView->frameView()->invalidateScrollbar(horizontalScrollbar, IntRect(IntPoint(0, 0), horizontalScrollbar->frameRect().size()));
}
if (m_layerForVerticalScrollbar) {
m_layerForVerticalScrollbar->removeFromParent();
m_layerForVerticalScrollbar = nullptr;
if (Scrollbar* verticalScrollbar = m_renderView->frameView()->verticalScrollbar())
- m_renderView->frameView()->invalidateScrollbar(verticalScrollbar, LayoutRect(LayoutPoint(0, 0), verticalScrollbar->frameRect().size()));
+ m_renderView->frameView()->invalidateScrollbar(verticalScrollbar, IntRect(IntPoint(0, 0), verticalScrollbar->frameRect().size()));
}
if (m_layerForScrollCorner) {
diff --git a/Source/WebCore/rendering/RenderLayerCompositor.h b/Source/WebCore/rendering/RenderLayerCompositor.h
index c9aab92..be3bc084 100644
--- a/Source/WebCore/rendering/RenderLayerCompositor.h
+++ b/Source/WebCore/rendering/RenderLayerCompositor.h
@@ -121,7 +121,7 @@
bool needsContentsCompositingLayer(const RenderLayer*) const;
// Return the bounding box required for compositing layer and its childern, relative to ancestorLayer.
// If layerBoundingBox is not 0, on return it contains the bounding box of this layer only.
- LayoutRect calculateCompositedBounds(const RenderLayer*, const RenderLayer* ancestorLayer);
+ IntRect calculateCompositedBounds(const RenderLayer*, const RenderLayer* ancestorLayer);
// Repaint the appropriate layers when the given RenderLayer starts or stops being composited.
void repaintOnCompositingChange(RenderLayer*);
@@ -134,7 +134,7 @@
RenderLayer* enclosingNonStackingClippingLayer(const RenderLayer* layer) const;
// Repaint parts of all composited layers that intersect the given absolute rectangle.
- void repaintCompositedLayersAbsoluteRect(const LayoutRect&);
+ void repaintCompositedLayersAbsoluteRect(const IntRect&);
RenderLayer* rootRenderLayer() const;
GraphicsLayer* rootGraphicsLayer() const;
@@ -183,7 +183,7 @@
static bool parentFrameContentLayers(RenderPart*);
// Update the geometry of the layers used for clipping and scrolling in frames.
- void frameViewDidChangeLocation(const LayoutPoint& contentsOffset);
+ void frameViewDidChangeLocation(const IntPoint& contentsOffset);
void frameViewDidChangeSize();
void frameViewDidScroll();
@@ -215,7 +215,7 @@
// GraphicsLayerClient Implementation
virtual void notifyAnimationStarted(const GraphicsLayer*, double) { }
virtual void notifySyncRequired(const GraphicsLayer*) { scheduleLayerFlush(); }
- virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const LayoutRect&);
+ virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const IntRect&);
virtual bool showDebugBorders(const GraphicsLayer*) const;
virtual bool showRepaintCounter(const GraphicsLayer*) const;
@@ -233,12 +233,12 @@
void clearBackingForLayerIncludingDescendants(RenderLayer*);
// Repaint the given rect (which is layer's coords), and regions of child layers that intersect that rect.
- void recursiveRepaintLayerRect(RenderLayer*, const LayoutRect&);
+ void recursiveRepaintLayerRect(RenderLayer*, const IntRect&);
- typedef HashMap<RenderLayer*, LayoutRect> OverlapMap;
- void addToOverlapMap(OverlapMap&, RenderLayer*, LayoutRect& layerBounds, bool& boundsComputed);
+ typedef HashMap<RenderLayer*, IntRect> OverlapMap;
+ void addToOverlapMap(OverlapMap&, RenderLayer*, IntRect& layerBounds, bool& boundsComputed);
void addToOverlapMapRecursive(OverlapMap&, RenderLayer*);
- static bool overlapsCompositedLayers(OverlapMap&, const LayoutRect& layerBounds);
+ static bool overlapsCompositedLayers(OverlapMap&, const IntRect& layerBounds);
void updateCompositingLayersTimerFired(Timer<RenderLayerCompositor>*);
