Modified: trunk/Source/WebCore/rendering/RenderLayer.cpp (134310 => 134311)
--- trunk/Source/WebCore/rendering/RenderLayer.cpp 2012-11-12 22:36:07 UTC (rev 134310)
+++ trunk/Source/WebCore/rendering/RenderLayer.cpp 2012-11-12 22:42:22 UTC (rev 134311)
@@ -2941,7 +2941,10 @@
void RenderLayer::paint(GraphicsContext* context, const LayoutRect& damageRect, PaintBehavior paintBehavior, RenderObject* paintingRoot, RenderRegion* region, PaintLayerFlags paintFlags)
{
OverlapTestRequestMap overlapTestRequests;
- paintLayer(this, context, enclosingIntRect(damageRect), LayoutSize(), paintBehavior, paintingRoot, region, &overlapTestRequests, paintFlags);
+
+ LayerPaintingInfo paintingInfo(this, enclosingIntRect(damageRect), paintBehavior, LayoutSize(), paintingRoot, region, &overlapTestRequests);
+ paintLayer(context, paintingInfo, paintFlags);
+
OverlapTestRequestMap::iterator end = overlapTestRequests.end();
for (OverlapTestRequestMap::iterator it = overlapTestRequests.begin(); it != end; ++it)
it->key->setOverlapTestResult(false);
@@ -2951,8 +2954,10 @@
{
if (!m_containsDirtyOverlayScrollbars)
return;
- paintLayer(this, context, damageRect, LayoutSize(), paintBehavior, paintingRoot, 0, 0, PaintLayerHaveTransparency | PaintLayerTemporaryClipRects
- | PaintLayerPaintingOverlayScrollbars);
+
+ LayerPaintingInfo paintingInfo(this, enclosingIntRect(damageRect), paintBehavior, LayoutSize(), paintingRoot);
+ paintLayer(context, paintingInfo, PaintLayerHaveTransparency | PaintLayerTemporaryClipRects | PaintLayerPaintingOverlayScrollbars);
+
m_containsDirtyOverlayScrollbars = false;
}
@@ -3047,18 +3052,19 @@
}
-void RenderLayer::paintLayer(RenderLayer* rootLayer, GraphicsContext* context,
- const LayoutRect& paintDirtyRect, const LayoutSize& subPixelAccumulation, PaintBehavior paintBehavior,
- RenderObject* paintingRoot, RenderRegion* region, OverlapTestRequestMap* overlapTestRequests,
- PaintLayerFlags paintFlags)
+void RenderLayer::paintLayer(GraphicsContext* context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
{
#if USE(ACCELERATED_COMPOSITING)
if (isComposited()) {
// The updatingControlTints() painting pass goes through compositing layers,
// but we need to ensure that we don't cache clip rects computed with the wrong root in this case.
- if (context->updatingControlTints() || (paintBehavior & PaintBehaviorFlattenCompositingLayers))
+ if (context->updatingControlTints() || (paintingInfo.paintBehavior & PaintBehaviorFlattenCompositingLayers))
paintFlags |= PaintLayerTemporaryClipRects;
- else if (!backing()->paintsIntoWindow() && !backing()->paintsIntoCompositedAncestor() && !shouldDoSoftwarePaint(this, paintFlags & PaintLayerPaintingReflection) && !(rootLayer->containsDirtyOverlayScrollbars() && (paintFlags & PaintLayerPaintingOverlayScrollbars))) {
+ else if (!backing()->paintsIntoWindow()
+ && !backing()->paintsIntoCompositedAncestor()
+ && !shouldDoSoftwarePaint(this, paintFlags & PaintLayerPaintingReflection)
+ && !(paintingInfo.rootLayer->containsDirtyOverlayScrollbars()
+ && (paintFlags & PaintLayerPaintingOverlayScrollbars))) {
// If this RenderLayer should paint into its backing, that will be done via RenderLayerBacking::paintIntoLayer().
return;
}
@@ -3076,12 +3082,12 @@
if (!renderer()->opacity())
return;
- if (paintsWithTransparency(paintBehavior))
+ if (paintsWithTransparency(paintingInfo.paintBehavior))
paintFlags |= PaintLayerHaveTransparency;
// PaintLayerAppliedTransform is used in RenderReplica, to avoid applying the transform twice.
- if (paintsWithTransform(paintBehavior) && !(paintFlags & PaintLayerAppliedTransform)) {
- TransformationMatrix layerTransform = renderableTransform(paintBehavior);
+ if (paintsWithTransform(paintingInfo.paintBehavior) && !(paintFlags & PaintLayerAppliedTransform)) {
+ TransformationMatrix layerTransform = renderableTransform(paintingInfo.paintBehavior);
// If the transform can't be inverted, then don't paint anything.
if (!layerTransform.isInvertible())
return;
@@ -3090,31 +3096,31 @@
// layer from the parent now, assuming there is a parent
if (paintFlags & PaintLayerHaveTransparency) {
if (parent())
- parent()->beginTransparencyLayers(context, rootLayer, paintDirtyRect, paintBehavior);
+ parent()->beginTransparencyLayers(context, paintingInfo.rootLayer, paintingInfo.paintDirtyRect, paintingInfo.paintBehavior);
else
- beginTransparencyLayers(context, rootLayer, paintDirtyRect, paintBehavior);
+ beginTransparencyLayers(context, paintingInfo.rootLayer, paintingInfo.paintDirtyRect, paintingInfo.paintBehavior);
}
// Make sure the parent's clip rects have been calculated.
- ClipRect clipRect = paintDirtyRect;
+ ClipRect clipRect = paintingInfo.paintDirtyRect;
if (parent()) {
- clipRect = backgroundClipRect(rootLayer, region, (paintFlags & PaintLayerTemporaryClipRects) ? TemporaryClipRects : PaintingClipRects,
+ clipRect = backgroundClipRect(paintingInfo.rootLayer, paintingInfo.region, (paintFlags & PaintLayerTemporaryClipRects) ? TemporaryClipRects : PaintingClipRects,
IgnoreOverlayScrollbarSize, (paintFlags & PaintLayerPaintingOverflowContents) ? IgnoreOverflowClip : RespectOverflowClip);
- clipRect.intersect(paintDirtyRect);
+ clipRect.intersect(paintingInfo.paintDirtyRect);
// Push the parent coordinate space's clip.
- parent()->clipToRect(rootLayer, context, paintDirtyRect, clipRect);
+ parent()->clipToRect(paintingInfo.rootLayer, context, paintingInfo.paintDirtyRect, clipRect);
}
// Adjust the transform such that the renderer's upper left corner will paint at (0,0) in user space.
// This involves subtracting out the position of the layer in our current coordinate space, but preserving
// the accumulated error for sub-pixel layout.
LayoutPoint delta;
- convertToLayerCoords(rootLayer, delta);
+ convertToLayerCoords(paintingInfo.rootLayer, delta);
TransformationMatrix transform(layerTransform);
IntPoint roundedDelta = roundedIntPoint(delta);
transform.translateRight(roundedDelta.x(), roundedDelta.y());
- LayoutSize adjustedSubPixelAccumulation = subPixelAccumulation + (delta - roundedDelta);
+ LayoutSize adjustedSubPixelAccumulation = paintingInfo.subPixelAccumulation + (delta - roundedDelta);
// Apply the transform.
{
@@ -3122,23 +3128,21 @@
context->concatCTM(transform.toAffineTransform());
// Now do a paint with the root layer shifted to be us.
- paintLayerContentsAndReflection(this, context, enclosingIntRect(transform.inverse().mapRect(paintDirtyRect)), adjustedSubPixelAccumulation, paintBehavior, paintingRoot, region, overlapTestRequests, paintFlags);
+ LayerPaintingInfo transformedPaintingInfo(this, enclosingIntRect(transform.inverse().mapRect(paintingInfo.paintDirtyRect)), paintingInfo.paintBehavior, adjustedSubPixelAccumulation, paintingInfo.paintingRoot, paintingInfo.region, paintingInfo.overlapTestRequests);
+ paintLayerContentsAndReflection(context, transformedPaintingInfo, paintFlags);
}
// Restore the clip.
if (parent())
- parent()->restoreClip(context, paintDirtyRect, clipRect);
+ parent()->restoreClip(context, paintingInfo.paintDirtyRect, clipRect);
return;
}
- paintLayerContentsAndReflection(rootLayer, context, paintDirtyRect, subPixelAccumulation, paintBehavior, paintingRoot, region, overlapTestRequests, paintFlags);
+ paintLayerContentsAndReflection(context, paintingInfo, paintFlags);
}
-void RenderLayer::paintLayerContentsAndReflection(RenderLayer* rootLayer, GraphicsContext* context,
- const LayoutRect& paintDirtyRect, const LayoutSize& subPixelAccumulation, PaintBehavior paintBehavior,
- RenderObject* paintingRoot, RenderRegion* region, OverlapTestRequestMap* overlapTestRequests,
- PaintLayerFlags paintFlags)
+void RenderLayer::paintLayerContentsAndReflection(GraphicsContext* context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
{
ASSERT(isSelfPaintingLayer() || hasSelfPaintingLayerDescendant());
@@ -3148,18 +3152,15 @@
if (m_reflection && !m_paintingInsideReflection) {
// Mark that we are now inside replica painting.
m_paintingInsideReflection = true;
- reflectionLayer()->paintLayer(rootLayer, context, paintDirtyRect, subPixelAccumulation, paintBehavior, paintingRoot, region, overlapTestRequests, localPaintFlags | PaintLayerPaintingReflection);
+ reflectionLayer()->paintLayer(context, paintingInfo, localPaintFlags | PaintLayerPaintingReflection);
m_paintingInsideReflection = false;
}
localPaintFlags |= PaintLayerPaintingCompositingAllPhases;
- paintLayerContents(rootLayer, context, paintDirtyRect, subPixelAccumulation, paintBehavior, paintingRoot, region, overlapTestRequests, localPaintFlags);
+ paintLayerContents(context, paintingInfo, localPaintFlags);
}
-void RenderLayer::paintLayerContents(RenderLayer* rootLayer, GraphicsContext* context,
- const LayoutRect& parentPaintDirtyRect, const LayoutSize& subPixelAccumulation, PaintBehavior paintBehavior,
- RenderObject* paintingRoot, RenderRegion* region, OverlapTestRequestMap* overlapTestRequests,
- PaintLayerFlags paintFlags)
+void RenderLayer::paintLayerContents(GraphicsContext* context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
{
ASSERT(isSelfPaintingLayer() || hasSelfPaintingLayerDescendant());
@@ -3175,7 +3176,7 @@
LayoutRect layerBounds;
ClipRect damageRect, clipRectToApply, outlineRect;
LayoutPoint paintOffset;
- LayoutRect paintDirtyRect = parentPaintDirtyRect;
+ LayoutRect paintDirtyRect = paintingInfo.paintDirtyRect;
bool useClipRect = true;
GraphicsContext* transparencyLayerContext = context;
@@ -3192,7 +3193,7 @@
hasClipPath = true;
context->save();
ShapeClipPathOperation* clipPath = static_cast<ShapeClipPathOperation*>(style->clipPath());
- context->clipPath(clipPath->path(calculateLayerBounds(this, rootLayer, 0)), clipPath->windRule());
+ context->clipPath(clipPath->path(calculateLayerBounds(this, paintingInfo.rootLayer, 0)), clipPath->windRule());
}
#if ENABLE(SVG)
else if (style->clipPath()->getOperationType() == ClipPathOperation::REFERENCE) {
@@ -3201,7 +3202,7 @@
// FIXME: It doesn't work with forward or external SVG references (https://bugs.webkit.org/show_bug.cgi?id=90405)
Element* element = document ? document->getElementById(referenceClipPathOperation->fragment()) : 0;
if (element && element->hasTagName(SVGNames::clipPathTag) && element->renderer())
- static_cast<RenderSVGResourceClipper*>(element->renderer())->applyClippingToContext(renderer(), calculateLayerBounds(this, rootLayer, 0), paintDirtyRect, context);
+ static_cast<RenderSVGResourceClipper*>(element->renderer())->applyClippingToContext(renderer(), calculateLayerBounds(this, paintingInfo.rootLayer, 0), paintingInfo.paintDirtyRect, context);
}
#endif
}
@@ -3210,12 +3211,12 @@
FilterEffectRendererHelper filterPainter(filterRenderer() && paintsWithFilters());
if (filterPainter.haveFilterEffect() && !context->paintingDisabled()) {
LayoutPoint rootLayerOffset;
- convertToLayerCoords(rootLayer, rootLayerOffset);
+ convertToLayerCoords(paintingInfo.rootLayer, rootLayerOffset);
RenderLayerFilterInfo* filterInfo = this->filterInfo();
ASSERT(filterInfo);
LayoutRect filterRepaintRect = filterInfo->dirtySourceRect();
filterRepaintRect.move(rootLayerOffset.x(), rootLayerOffset.y());
- if (filterPainter.prepareFilterEffect(this, calculateLayerBounds(this, rootLayer, 0), parentPaintDirtyRect, filterRepaintRect)) {
+ if (filterPainter.prepareFilterEffect(this, calculateLayerBounds(this, paintingInfo.rootLayer, 0), paintingInfo.paintDirtyRect, filterRepaintRect)) {
// Now we know for sure, that the source image will be updated, so we can revert our tracking repaint rect back to zero.
filterInfo->resetDirtySourceRect();
@@ -3238,55 +3239,55 @@
#endif
if (shouldPaintContent || shouldPaintOutline || isPaintingOverlayScrollbars) {
- calculateRects(rootLayer, region, (localPaintFlags & PaintLayerTemporaryClipRects) ? TemporaryClipRects : PaintingClipRects, paintDirtyRect, layerBounds, damageRect, clipRectToApply, outlineRect,
+ calculateRects(paintingInfo.rootLayer, paintingInfo.region, (localPaintFlags & PaintLayerTemporaryClipRects) ? TemporaryClipRects : PaintingClipRects, paintDirtyRect, layerBounds, damageRect, clipRectToApply, outlineRect,
IgnoreOverlayScrollbarSize, localPaintFlags & PaintLayerPaintingOverflowContents ? IgnoreOverflowClip : RespectOverflowClip);
- paintOffset = toPoint(layerBounds.location() - renderBoxLocation() + subPixelAccumulation);
- if (this == rootLayer)
+ paintOffset = toPoint(layerBounds.location() - renderBoxLocation() + paintingInfo.subPixelAccumulation);
+ if (this == paintingInfo.rootLayer)
paintOffset = roundedIntPoint(paintOffset);
}
- bool forceBlackText = paintBehavior & PaintBehaviorForceBlackText;
- bool selectionOnly = paintBehavior & PaintBehaviorSelectionOnly;
+ bool forceBlackText = paintingInfo.paintBehavior & PaintBehaviorForceBlackText;
+ bool selectionOnly = paintingInfo.paintBehavior & PaintBehaviorSelectionOnly;
// If this layer's renderer is a child of the paintingRoot, we render unconditionally, which
// is done by passing a nil paintingRoot down to our renderer (as if no paintingRoot was ever set).
// Else, our renderer tree may or may not contain the painting root, so we pass that root along
// so it will be tested against as we descend through the renderers.
RenderObject* paintingRootForRenderer = 0;
- if (paintingRoot && !renderer()->isDescendantOf(paintingRoot))
- paintingRootForRenderer = paintingRoot;
+ if (paintingInfo.paintingRoot && !renderer()->isDescendantOf(paintingInfo.paintingRoot))
+ paintingRootForRenderer = paintingInfo.paintingRoot;
- if (overlapTestRequests && isSelfPaintingLayer)
- performOverlapTests(*overlapTestRequests, rootLayer, this);
+ if (paintingInfo.overlapTestRequests && isSelfPaintingLayer)
+ performOverlapTests(*paintingInfo.overlapTestRequests, paintingInfo.rootLayer, this);
// We want to paint our layer, but only if we intersect the damage rect.
- if (this != rootLayer || !(localPaintFlags & PaintLayerPaintingOverflowContents))
- shouldPaintContent &= intersectsDamageRect(layerBounds, damageRect.rect(), rootLayer);
+ if (this != paintingInfo.rootLayer || !(localPaintFlags & PaintLayerPaintingOverflowContents))
+ shouldPaintContent &= intersectsDamageRect(layerBounds, damageRect.rect(), paintingInfo.rootLayer);
if (localPaintFlags & PaintLayerPaintingCompositingBackgroundPhase) {
if (shouldPaintContent && !selectionOnly) {
// Begin transparency layers lazily now that we know we have to paint something.
if (haveTransparency)
- beginTransparencyLayers(transparencyLayerContext, rootLayer, paintDirtyRect, paintBehavior);
+ beginTransparencyLayers(transparencyLayerContext, paintingInfo.rootLayer, paintingInfo.paintDirtyRect, paintingInfo.paintBehavior);
if (useClipRect) {
// Paint our background first, before painting any child layers.
// Establish the clip used to paint our background.
- clipToRect(rootLayer, context, paintDirtyRect, damageRect, DoNotIncludeSelfForBorderRadius); // Background painting will handle clipping to self.
+ clipToRect(paintingInfo.rootLayer, context, paintingInfo.paintDirtyRect, damageRect, DoNotIncludeSelfForBorderRadius); // Background painting will handle clipping to self.
}
// Paint the background.
- PaintInfo paintInfo(context, pixelSnappedIntRect(damageRect.rect()), PaintPhaseBlockBackground, false, paintingRootForRenderer, region, 0);
+ PaintInfo paintInfo(context, pixelSnappedIntRect(damageRect.rect()), PaintPhaseBlockBackground, false, paintingRootForRenderer, paintingInfo.region, 0);
renderer()->paint(paintInfo, paintOffset);
if (useClipRect) {
// Restore the clip.
- restoreClip(context, paintDirtyRect, damageRect);
+ restoreClip(context, paintingInfo.paintDirtyRect, damageRect);
}
}
// Now walk the sorted list of children with negative z-indices.
- paintList(negZOrderList(), rootLayer, context, paintDirtyRect, paintBehavior, paintingRoot, region, overlapTestRequests, localPaintFlags);
+ paintList(negZOrderList(), context, paintingInfo, localPaintFlags);
}
if (localPaintFlags & PaintLayerPaintingCompositingForegroundPhase) {
@@ -3294,22 +3295,22 @@
if (shouldPaintContent && !clipRectToApply.isEmpty()) {
// Begin transparency layers lazily now that we know we have to paint something.
if (haveTransparency)
- beginTransparencyLayers(transparencyLayerContext, rootLayer, paintDirtyRect, paintBehavior);
+ beginTransparencyLayers(transparencyLayerContext, paintingInfo.rootLayer, paintingInfo.paintDirtyRect, paintingInfo.paintBehavior);
if (useClipRect) {
// Set up the clip used when painting our children.
- clipToRect(rootLayer, context, paintDirtyRect, clipRectToApply);
+ clipToRect(paintingInfo.rootLayer, context, paintingInfo.paintDirtyRect, clipRectToApply);
}
PaintInfo paintInfo(context, pixelSnappedIntRect(clipRectToApply.rect()),
selectionOnly ? PaintPhaseSelection : PaintPhaseChildBlockBackgrounds,
- forceBlackText, paintingRootForRenderer, region, 0);
+ forceBlackText, paintingRootForRenderer, paintingInfo.region, 0);
renderer()->paint(paintInfo, paintOffset);
if (!selectionOnly) {
paintInfo.phase = PaintPhaseFloat;
renderer()->paint(paintInfo, paintOffset);
paintInfo.phase = PaintPhaseForeground;
- paintInfo.overlapTestRequests = overlapTestRequests;
+ paintInfo.overlapTestRequests = paintingInfo.overlapTestRequests;
renderer()->paint(paintInfo, paintOffset);
paintInfo.phase = PaintPhaseChildOutlines;
renderer()->paint(paintInfo, paintOffset);
@@ -3317,37 +3318,37 @@
if (useClipRect) {
// Now restore our clip.
- restoreClip(context, paintDirtyRect, clipRectToApply);
+ restoreClip(context, paintingInfo.paintDirtyRect, clipRectToApply);
}
}
if (shouldPaintOutline && !outlineRect.isEmpty()) {
// Paint our own outline
- PaintInfo paintInfo(context, pixelSnappedIntRect(outlineRect.rect()), PaintPhaseSelfOutline, false, paintingRootForRenderer, region, 0);
- clipToRect(rootLayer, context, paintDirtyRect, outlineRect, DoNotIncludeSelfForBorderRadius);
+ PaintInfo paintInfo(context, pixelSnappedIntRect(outlineRect.rect()), PaintPhaseSelfOutline, false, paintingRootForRenderer, paintingInfo.region, 0);
+ clipToRect(paintingInfo.rootLayer, context, paintingInfo.paintDirtyRect, outlineRect, DoNotIncludeSelfForBorderRadius);
renderer()->paint(paintInfo, paintOffset);
- restoreClip(context, paintDirtyRect, outlineRect);
+ restoreClip(context, paintingInfo.paintDirtyRect, outlineRect);
}
// Paint any child layers that have overflow.
- paintList(m_normalFlowList, rootLayer, context, paintDirtyRect, paintBehavior, paintingRoot, region, overlapTestRequests, localPaintFlags);
+ paintList(m_normalFlowList, context, paintingInfo, localPaintFlags);
// Now walk the sorted list of children with positive z-indices.
- paintList(posZOrderList(), rootLayer, context, paintDirtyRect, paintBehavior, paintingRoot, region, overlapTestRequests, localPaintFlags);
+ paintList(posZOrderList(), context, paintingInfo, localPaintFlags);
}
if (isPaintingOverlayScrollbars) {
- clipToRect(rootLayer, context, paintDirtyRect, damageRect);
+ clipToRect(paintingInfo.rootLayer, context, paintDirtyRect, damageRect);
paintOverflowControls(context, roundedIntPoint(paintOffset), pixelSnappedIntRect(damageRect.rect()), true);
- restoreClip(context, paintDirtyRect, damageRect);
+ restoreClip(context, paintingInfo.paintDirtyRect, damageRect);
}
#if ENABLE(CSS_FILTERS)
if (filterPainter.hasStartedFilterEffect()) {
// Apply the correct clipping (ie. overflow: hidden).
- clipToRect(rootLayer, transparencyLayerContext, paintDirtyRect, damageRect);
+ clipToRect(paintingInfo.rootLayer, transparencyLayerContext, paintingInfo.paintDirtyRect, damageRect);
context = filterPainter.applyFilterEffect();
- restoreClip(transparencyLayerContext, paintDirtyRect, damageRect);
+ restoreClip(transparencyLayerContext, paintingInfo.paintDirtyRect, damageRect);
}
#endif
@@ -3356,15 +3357,15 @@
if ((localPaintFlags & PaintLayerPaintingCompositingMaskPhase) && shouldPaintContent && renderer()->hasMask() && !selectionOnly) {
if (useClipRect)
- clipToRect(rootLayer, context, paintDirtyRect, damageRect, DoNotIncludeSelfForBorderRadius); // Mask painting will handle clipping to self.
+ clipToRect(paintingInfo.rootLayer, context, paintingInfo.paintDirtyRect, damageRect, DoNotIncludeSelfForBorderRadius); // Mask painting will handle clipping to self.
// Paint the mask.
- PaintInfo paintInfo(context, pixelSnappedIntRect(damageRect.rect()), PaintPhaseMask, false, paintingRootForRenderer, region, 0);
+ PaintInfo paintInfo(context, pixelSnappedIntRect(damageRect.rect()), PaintPhaseMask, false, paintingRootForRenderer, paintingInfo.region, 0);
renderer()->paint(paintInfo, paintOffset);
if (useClipRect) {
// Restore the clip.
- restoreClip(context, paintDirtyRect, damageRect);
+ restoreClip(context, paintingInfo.paintDirtyRect, damageRect);
}
}
@@ -3379,10 +3380,7 @@
context->restore();
}
-void RenderLayer::paintList(Vector<RenderLayer*>* list, RenderLayer* rootLayer, GraphicsContext* context,
- const LayoutRect& paintDirtyRect, PaintBehavior paintBehavior,
- RenderObject* paintingRoot, RenderRegion* region, OverlapTestRequestMap* overlapTestRequests,
- PaintLayerFlags paintFlags)
+void RenderLayer::paintList(Vector<RenderLayer*>* list, GraphicsContext* context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
{
if (!list)
return;
@@ -3397,16 +3395,13 @@
for (size_t i = 0; i < list->size(); ++i) {
RenderLayer* childLayer = list->at(i);
if (!childLayer->isPaginated())
- childLayer->paintLayer(rootLayer, context, paintDirtyRect, LayoutSize(), paintBehavior, paintingRoot, region, overlapTestRequests, paintFlags);
+ childLayer->paintLayer(context, paintingInfo, paintFlags);
else
- paintPaginatedChildLayer(childLayer, rootLayer, context, paintDirtyRect, paintBehavior, paintingRoot, region, overlapTestRequests, paintFlags);
+ paintPaginatedChildLayer(childLayer, context, paintingInfo, paintFlags);
}
}
-void RenderLayer::paintPaginatedChildLayer(RenderLayer* childLayer, RenderLayer* rootLayer, GraphicsContext* context,
- const LayoutRect& paintDirtyRect, PaintBehavior paintBehavior,
- RenderObject* paintingRoot, RenderRegion* region, OverlapTestRequestMap* overlapTestRequests,
- PaintLayerFlags paintFlags)
+void RenderLayer::paintPaginatedChildLayer(RenderLayer* childLayer, GraphicsContext* context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
{
// We need to do multiple passes, breaking up our child layer into strips.
Vector<RenderLayer*> columnLayers;
@@ -3424,13 +3419,11 @@
if (!columnLayers.size())
return;
- paintChildLayerIntoColumns(childLayer, rootLayer, context, paintDirtyRect, paintBehavior, paintingRoot, region, overlapTestRequests, paintFlags, columnLayers, columnLayers.size() - 1);
+ paintChildLayerIntoColumns(childLayer, context, paintingInfo, paintFlags, columnLayers, columnLayers.size() - 1);
}
-void RenderLayer::paintChildLayerIntoColumns(RenderLayer* childLayer, RenderLayer* rootLayer, GraphicsContext* context,
- const LayoutRect& paintDirtyRect, PaintBehavior paintBehavior,
- RenderObject* paintingRoot, RenderRegion* region, OverlapTestRequestMap* overlapTestRequests,
- PaintLayerFlags paintFlags, const Vector<RenderLayer*>& columnLayers, size_t colIndex)
+void RenderLayer::paintChildLayerIntoColumns(RenderLayer* childLayer, GraphicsContext* context, const LayerPaintingInfo& paintingInfo,
+ PaintLayerFlags paintFlags, const Vector<RenderLayer*>& columnLayers, size_t colIndex)
{
RenderBlock* columnBlock = toRenderBlock(columnLayers[colIndex]->renderer());
@@ -3441,7 +3434,7 @@
LayoutPoint layerOffset;
// FIXME: It looks suspicious to call convertToLayerCoords here
// as canUseConvertToLayerCoords is true for this layer.
- columnBlock->layer()->convertToLayerCoords(rootLayer, layerOffset);
+ columnBlock->layer()->convertToLayerCoords(paintingInfo.rootLayer, layerOffset);
bool isHorizontal = columnBlock->style()->isHorizontalWritingMode();
@@ -3468,7 +3461,7 @@
colRect.moveBy(layerOffset);
- LayoutRect localDirtyRect(paintDirtyRect);
+ LayoutRect localDirtyRect(paintingInfo.paintDirtyRect);
localDirtyRect.intersect(colRect);
if (!localDirtyRect.isEmpty()) {
@@ -3488,7 +3481,11 @@
newTransform.translateRight(roundToInt(offset.width()), roundToInt(offset.height()));
childLayer->m_transform = adoptPtr(new TransformationMatrix(newTransform));
- childLayer->paintLayer(rootLayer, context, localDirtyRect, LayoutSize(), paintBehavior, paintingRoot, region, overlapTestRequests, paintFlags);
+
+ LayerPaintingInfo localPaintingInfo(paintingInfo);
+ localPaintingInfo.paintDirtyRect = localDirtyRect;
+ childLayer->paintLayer(context, localPaintingInfo, paintFlags);
+
if (oldHasTransform)
childLayer->m_transform = adoptPtr(new TransformationMatrix(oldTransform));
else
@@ -3497,7 +3494,7 @@
// Adjust the transform such that the renderer's upper left corner will paint at (0,0) in user space.
// This involves subtracting out the position of the layer in our current coordinate space.
LayoutPoint childOffset;
- columnLayers[colIndex - 1]->convertToLayerCoords(rootLayer, childOffset);
+ columnLayers[colIndex - 1]->convertToLayerCoords(paintingInfo.rootLayer, childOffset);
TransformationMatrix transform;
transform.translateRight(roundToInt(childOffset.x() + offset.width()), roundToInt(childOffset.y() + offset.height()));
@@ -3505,9 +3502,10 @@
context->concatCTM(transform.toAffineTransform());
// Now do a paint with the root layer shifted to be the next multicol block.
- paintChildLayerIntoColumns(childLayer, columnLayers[colIndex - 1], context, transform.inverse().mapRect(localDirtyRect), paintBehavior,
- paintingRoot, region, overlapTestRequests, paintFlags,
- columnLayers, colIndex - 1);
+ LayerPaintingInfo columnPaintingInfo(paintingInfo);
+ columnPaintingInfo.rootLayer = columnLayers[colIndex - 1];
+ columnPaintingInfo.paintDirtyRect = transform.inverse().mapRect(localDirtyRect);
+ paintChildLayerIntoColumns(childLayer, context, columnPaintingInfo, paintFlags, columnLayers, colIndex - 1);
}
}
