void CoordinatedGraphicsLayer::flushCompositingStateForThisLayerOnly()
{
ASSERT(m_coordinator->isFlushingLayerChanges());
// When we have a transform animation, we need to update visible rect every frame to adjust the visible rect of a backing store.
bool hasActiveTransformAnimation = selfOrAncestorHasActiveTransformAnimation();
if (hasActiveTransformAnimation)
m_movingVisibleRect = true;
// Sets the values.
computePixelAlignment(m_adjustedPosition, m_adjustedSize, m_adjustedAnchorPoint, m_pixelAlignmentOffset);
syncImageBacking();
syncLayerState();
syncAnimations();
computeTransformedVisibleRect();
syncChildren();
#if ENABLE(CSS_FILTERS)
syncFilters();
#endif
#if USE(GRAPHICS_SURFACE)
syncCanvas();
#endif
// Only unset m_movingVisibleRect after we have updated the visible rect after the animation stopped.
if (!hasActiveTransformAnimation)
m_movingVisibleRect = false;
}
void TextureMapperLayer::syncAnimationsRecursively()
{
syncAnimations();
for (int i = m_children.size() - 1; i >= 0; --i)
m_children[i]->syncAnimationsRecursively();
}
void TextureMapperLayer::flushCompositingStateForThisLayerOnly(GraphicsLayerTextureMapper* graphicsLayer)
{
ASSERT(graphicsLayer);
int changeMask = graphicsLayer->changeMask();
if (changeMask == NoChanges && graphicsLayer->m_animations.isEmpty())
return;
graphicsLayer->updateDebugIndicators();
if (changeMask & ChildrenChange)
setChildren(graphicsLayer->children());
if (changeMask & MaskLayerChange) {
if (TextureMapperLayer* layer = toTextureMapperLayer(graphicsLayer->maskLayer()))
layer->m_effectTarget = this;
}
if (changeMask & ReplicaLayerChange) {
if (TextureMapperLayer* layer = toTextureMapperLayer(graphicsLayer->replicaLayer()))
layer->m_effectTarget = this;
}
if (changeMask & AnimationChange)
m_animations = graphicsLayer->m_animations;
m_state.maskLayer = toTextureMapperLayer(graphicsLayer->maskLayer());
m_state.replicaLayer = toTextureMapperLayer(graphicsLayer->replicaLayer());
m_state.pos = graphicsLayer->position();
m_state.anchorPoint = graphicsLayer->anchorPoint();
m_state.size = graphicsLayer->size();
m_state.transform = graphicsLayer->transform();
m_state.contentsRect = graphicsLayer->contentsRect();
m_state.preserves3D = graphicsLayer->preserves3D();
m_state.masksToBounds = graphicsLayer->masksToBounds();
m_state.drawsContent = graphicsLayer->drawsContent();
m_state.contentsVisible = graphicsLayer->contentsAreVisible();
m_state.contentsOpaque = graphicsLayer->contentsOpaque();
m_state.backfaceVisibility = graphicsLayer->backfaceVisibility();
m_state.childrenTransform = graphicsLayer->childrenTransform();
m_state.opacity = graphicsLayer->opacity();
m_state.solidColor = graphicsLayer->solidColor();
#if ENABLE(CSS_FILTERS)
if (changeMask & FilterChange)
m_state.filters = graphicsLayer->filters();
#endif
m_fixedToViewport = graphicsLayer->fixedToViewport();
m_contentsLayer = graphicsLayer->platformLayer();
m_transform.setPosition(adjustedPosition());
m_transform.setAnchorPoint(m_state.anchorPoint);
m_transform.setSize(m_state.size);
m_transform.setFlattening(!m_state.preserves3D);
m_transform.setChildrenTransform(m_state.childrenTransform);
syncAnimations();
}
void TextureMapperLayer::syncCompositingState(GraphicsLayerTextureMapper* graphicsLayer, TextureMapper* textureMapper, int options)
{
if (!textureMapper)
return;
if (graphicsLayer && !(options & ComputationsOnly)) {
syncCompositingStateSelf(graphicsLayer, textureMapper);
graphicsLayer->didSynchronize();
}
if (graphicsLayer && m_state.maskLayer) {
m_state.maskLayer->syncCompositingState(toGraphicsLayerTextureMapper(graphicsLayer->maskLayer()), textureMapper);
// A mask layer has its parent's size by default, in case it's not set specifically.
if (m_state.maskLayer->m_size.isEmpty())
m_state.maskLayer->m_size = m_size;
}
if (m_state.replicaLayer)
m_state.replicaLayer->syncCompositingState(toGraphicsLayerTextureMapper(graphicsLayer->replicaLayer()), textureMapper);
syncAnimations();
updateBackingStore(textureMapper, graphicsLayer);
if (!(options & TraverseDescendants))
options = ComputationsOnly;
if (graphicsLayer) {
Vector<GraphicsLayer*> children = graphicsLayer->children();
for (int i = children.size() - 1; i >= 0; --i) {
TextureMapperLayer* layer = toTextureMapperLayer(children[i]);
if (!layer)
continue;
layer->syncCompositingState(toGraphicsLayerTextureMapper(children[i]), textureMapper, options);
}
} else {
for (int i = m_children.size() - 1; i >= 0; --i)
m_children[i]->syncCompositingState(0, textureMapper, options);
}
}
void TextureMapperLayer::applyAnimationsRecursively()
{
syncAnimations();
for (auto* child : m_children)
child->applyAnimationsRecursively();
}
void TextureMapperLayer::applyAnimationsRecursively()
{
syncAnimations();
for (size_t i = 0; i < m_children.size(); ++i)
m_children[i]->applyAnimationsRecursively();
}
