AffineTransform SVGLayoutSupport::deprecatedCalculateTransformToLayer(
const LayoutObject* layoutObject) {
AffineTransform transform;
while (layoutObject) {
transform = layoutObject->localToSVGParentTransform() * transform;
if (layoutObject->isSVGRoot())
break;
layoutObject = layoutObject->parent();
}
// Continue walking up the layer tree, accumulating CSS transforms.
// FIXME: this queries layer compositing state - which is not
// supported during layout. Hence, the result may not include all CSS
// transforms.
PaintLayer* layer = layoutObject ? layoutObject->enclosingLayer() : 0;
while (layer && layer->isAllowedToQueryCompositingState()) {
// We can stop at compositing layers, to match the backing resolution.
// FIXME: should we be computing the transform to the nearest composited
// layer, or the nearest composited layer that does not paint into its
// ancestor? I think this is the nearest composited ancestor since we will
// inherit its transforms in the composited layer tree.
if (layer->compositingState() != NotComposited)
break;
if (TransformationMatrix* layerTransform = layer->transform())
transform = layerTransform->toAffineTransform() * transform;
layer = layer->parent();
}
return transform;
}
static bool shouldCreateSubsequence(const PaintLayer& paintLayer, GraphicsContext& context, const PaintLayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
{
// Caching is not needed during printing.
if (context.printing())
return false;
// Don't create subsequence for a composited layer because if it can be cached,
// we can skip the whole painting in GraphicsLayer::paint() with CachedDisplayItemList.
// This also avoids conflict of PaintLayer::previousXXX() when paintLayer is composited
// scrolling and is painted twice for GraphicsLayers of container and scrolling contents.
if (paintLayer.compositingState() == PaintsIntoOwnBacking)
return false;
// Don't create subsequence during special painting to avoid cache conflict with normal painting.
if (paintingInfo.globalPaintFlags() & GlobalPaintFlattenCompositingLayers)
return false;
if (paintFlags & (PaintLayerPaintingReflection | PaintLayerPaintingRootBackgroundOnly | PaintLayerPaintingOverlayScrollbars | PaintLayerUncachedClipRects))
return false;
// Create subsequence for only stacking contexts whose painting are atomic.
if (!paintLayer.stackingNode()->isStackingContext())
return false;
// The layer doesn't have children. Subsequence caching is not worth because normally the actual painting will be cheap.
if (!PaintLayerStackingNodeIterator(*paintLayer.stackingNode(), AllChildren).next())
return false;
return true;
}
GraphicsLayer* PaintLayerCompositor::fixedRootBackgroundLayer() const
{
// Get the fixed root background from the LayoutView layer's compositedLayerMapping.
PaintLayer* viewLayer = m_layoutView.layer();
if (!viewLayer)
return nullptr;
if (viewLayer->compositingState() == PaintsIntoOwnBacking && viewLayer->compositedLayerMapping()->backgroundLayerPaintsFixedRootBackground())
return viewLayer->compositedLayerMapping()->backgroundLayer();
return nullptr;
}
static void paintLayers(PaintLayer& layer, SimDisplayItemList& displayList)
{
if (layer.isAllowedToQueryCompositingState() && layer.compositingState() == PaintsIntoOwnBacking) {
CompositedLayerMapping* mapping = layer.compositedLayerMapping();
GraphicsLayer* graphicsLayer = mapping->mainGraphicsLayer();
if (graphicsLayer->hasTrackedPaintInvalidations()) {
ContentLayerDelegate* delegate = graphicsLayer->contentLayerDelegateForTesting();
delegate->paintContents(&displayList, WebRect(0, 0, layer.size().width(), layer.size().height()));
graphicsLayer->resetTrackedPaintInvalidations();
}
}
for (PaintLayer* child = layer.firstChild(); child; child = child->nextSibling())
paintLayers(*child, displayList);
}
