void RenderGeometryMap::pushMappingsToAncestor(const RenderLayer* layer, const RenderLayer* ancestorLayer, bool respectTransforms)
{
MapCoordinatesFlags newFlags = respectTransforms ? m_mapCoordinatesFlags : m_mapCoordinatesFlags & ~UseTransforms;
SetForScope<MapCoordinatesFlags> flagsChange(m_mapCoordinatesFlags, newFlags);
const RenderLayerModelObject& renderer = layer->renderer();
// We have to visit all the renderers to detect flipped blocks. This might defeat the gains
// from mapping via layers.
bool canConvertInLayerTree = ancestorLayer ? canMapBetweenRenderersViaLayers(layer->renderer(), ancestorLayer->renderer()) : false;
if (canConvertInLayerTree) {
LayoutSize layerOffset = layer->offsetFromAncestor(ancestorLayer);
// The RenderView must be pushed first.
if (!m_mapping.size()) {
ASSERT(ancestorLayer->renderer().isRenderView());
pushMappingsToAncestor(&ancestorLayer->renderer(), nullptr);
}
SetForScope<size_t> positionChange(m_insertionPosition, m_mapping.size());
push(&renderer, layerOffset, /*accumulatingTransform*/ true, /*isNonUniform*/ false, /*isFixedPosition*/ false, /*hasTransform*/ false);
return;
}
const RenderLayerModelObject* ancestorRenderer = ancestorLayer ? &ancestorLayer->renderer() : nullptr;
pushMappingsToAncestor(&renderer, ancestorRenderer);
}
void LayoutGeometryMap::pushMappingsToAncestor(const PaintLayer* layer, const PaintLayer* ancestorLayer)
{
const LayoutObject* layoutObject = layer->layoutObject();
bool crossDocument = ancestorLayer && layer->layoutObject()->frame() != ancestorLayer->layoutObject()->frame();
ASSERT(!crossDocument || m_mapCoordinatesFlags & TraverseDocumentBoundaries);
// We have to visit all the layoutObjects to detect flipped blocks. This might defeat the gains
// from mapping via layers.
bool canConvertInLayerTree = (ancestorLayer && !crossDocument) ? canMapBetweenLayoutObjects(layer->layoutObject(), ancestorLayer->layoutObject()) : false;
LAYOUT_GEOMETRY_MAP_LOG("LayoutGeometryMap::pushMappingsToAncestor from layer %p to layer %p, canConvertInLayerTree=%d\n", layer, ancestorLayer, canConvertInLayerTree);
if (canConvertInLayerTree) {
LayoutPoint layerOffset;
layer->convertToLayerCoords(ancestorLayer, layerOffset);
// The LayoutView must be pushed first.
if (!m_mapping.size()) {
ASSERT(ancestorLayer->layoutObject()->isLayoutView());
pushMappingsToAncestor(ancestorLayer->layoutObject(), 0);
}
TemporaryChange<size_t> positionChange(m_insertionPosition, m_mapping.size());
bool accumulatingTransform = layer->layoutObject()->style()->preserves3D() || ancestorLayer->layoutObject()->style()->preserves3D();
push(layoutObject, toLayoutSize(layerOffset), accumulatingTransform ? AccumulatingTransform : 0);
return;
}
const LayoutBoxModelObject* ancestorLayoutObject = ancestorLayer ? ancestorLayer->layoutObject() : 0;
pushMappingsToAncestor(layoutObject, ancestorLayoutObject);
}
void RenderGeometryMap::pushMappingsToAncestor(const RenderLayer* layer, const RenderLayer* ancestorLayer)
{
const RenderObject& renderer = layer->renderer();
// We have to visit all the renderers to detect flipped blocks. This might defeat the gains
// from mapping via layers.
bool canConvertInLayerTree = ancestorLayer ? canMapBetweenRenderers(layer->renderer(), ancestorLayer->renderer()) : false;
// fprintf(stderr, "RenderGeometryMap::pushMappingsToAncestor from layer %p to layer %p, canConvertInLayerTree=%d\n", layer, ancestorLayer, canConvertInLayerTree);
if (canConvertInLayerTree) {
LayoutPoint layerOffset;
layer->convertToLayerCoords(ancestorLayer, layerOffset);
// The RenderView must be pushed first.
if (!m_mapping.size()) {
ASSERT(ancestorLayer->renderer().isRenderView());
pushMappingsToAncestor(&ancestorLayer->renderer(), 0);
}
TemporaryChange<size_t> positionChange(m_insertionPosition, m_mapping.size());
push(&renderer, toLayoutSize(layerOffset), /*accumulatingTransform*/ true, /*isNonUniform*/ false, /*isFixedPosition*/ false, /*hasTransform*/ false);
return;
}
const RenderLayerModelObject* ancestorRenderer = ancestorLayer ? &ancestorLayer->renderer() : 0;
pushMappingsToAncestor(&renderer, ancestorRenderer);
}
void RenderGeometryMap::pushMappingsToAncestor(
const RenderLayer* layer,
const RenderLayer* ancestorLayer) {
const RenderObject* renderer = layer->renderer();
bool crossDocument = false;
ASSERT(!crossDocument || m_mapCoordinatesFlags & TraverseDocumentBoundaries);
// We have to visit all the renderers to detect flipped blocks. This might
// defeat the gains from mapping via layers.
bool canConvertInLayerTree =
(ancestorLayer && !crossDocument)
? canMapBetweenRenderers(layer->renderer(), ancestorLayer->renderer())
: false;
// fprintf(stderr, "RenderGeometryMap::pushMappingsToAncestor from layer %p
// to layer %p, canConvertInLayerTree=%d\n", layer, ancestorLayer,
// canConvertInLayerTree);
if (canConvertInLayerTree) {
LayoutPoint layerOffset;
layer->convertToLayerCoords(ancestorLayer, layerOffset);
// The RenderView must be pushed first.
if (!m_mapping.size()) {
ASSERT(ancestorLayer->renderer()->isRenderView());
pushMappingsToAncestor(ancestorLayer->renderer(), 0);
}
TemporaryChange<size_t> positionChange(m_insertionPosition,
m_mapping.size());
bool accumulatingTransform =
layer->renderer()->style()->preserves3D() ||
ancestorLayer->renderer()->style()->preserves3D();
push(renderer, toLayoutSize(layerOffset), accumulatingTransform,
/*isNonUniform*/ false, /*hasTransform*/ false);
return;
}
const RenderBox* ancestorRenderer =
ancestorLayer ? ancestorLayer->renderer() : 0;
pushMappingsToAncestor(renderer, ancestorRenderer);
}
void RenderGeometryMap::pushMappingsToAncestor(const RenderLayer* layer, const RenderLayer* ancestorLayer)
{
const RenderObject* renderer = layer->renderer();
// The simple case can be handled fast in the layer tree.
bool canConvertInLayerTree = ancestorLayer ? canMapViaLayer(ancestorLayer) : false;
for (const RenderLayer* current = layer; current != ancestorLayer && canConvertInLayerTree; current = current->parent())
canConvertInLayerTree = canMapViaLayer(current);
if (canConvertInLayerTree) {
TemporaryChange<size_t> positionChange(m_insertionPosition, m_mapping.size());
LayoutPoint layerOffset;
layer->convertToLayerCoords(ancestorLayer, layerOffset);
push(renderer, toLayoutSize(layerOffset), /*accumulatingTransform*/ true, /*isNonUniform*/ false, /*isFixedPosition*/ false, /*hasTransform*/ false);
return;
}
const RenderBoxModelObject* ancestorRenderer = ancestorLayer ? ancestorLayer->renderer() : 0;
pushMappingsToAncestor(renderer, ancestorRenderer);
}
