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); }