void LayerTreeHostProxy::createTile(WebLayerID layerID, int tileID, float scale)
{
ensureLayer(layerID);
TextureMapperNode* node = toTextureMapperNode(layerByID(layerID));
int nodeTileID = node->createContentsTile(scale);
m_tileToNodeTile.add(tileID, nodeTileID);
}
void LayerTreeHostProxy::deleteLayer(WebLayerID layerID)
{
GraphicsLayer* layer = layerByID(layerID);
if (!layer)
return;
layer->removeFromParent();
m_layers.remove(layerID);
delete layer;
}
void CoordinatedGraphicsScene::setRootLayerID(CoordinatedLayerID layerID)
{
ASSERT(layerID != InvalidCoordinatedLayerID);
ASSERT(m_rootLayerID == InvalidCoordinatedLayerID);
m_rootLayerID = layerID;
TextureMapperLayer* layer = layerByID(layerID);
ASSERT(m_rootLayer->children().isEmpty());
m_rootLayer->addChild(layer);
}
void CoordinatedGraphicsScene::setLayerChildrenIfNeeded(TextureMapperLayer* layer, const CoordinatedGraphicsLayerState& state)
{
if (!state.childrenChanged)
return;
Vector<TextureMapperLayer*> children;
children.reserveCapacity(state.children.size());
for (auto& child : state.children)
children.append(layerByID(child));
layer->setChildren(children);
}
void LayerTreeHostProxy::removeTile(WebLayerID layerID, int tileID)
{
TextureMapperNode* node = toTextureMapperNode(layerByID(layerID));
if (!node)
return;
int nodeTileID = remoteTileIDToNodeTileID(tileID);
if (!nodeTileID)
return;
node->removeContentsTile(nodeTileID);
m_tileToNodeTile.remove(tileID);
}
void CoordinatedGraphicsScene::setLayerChildrenIfNeeded(TextureMapperLayer* layer, const CoordinatedGraphicsLayerState& state)
{
if (!state.childrenChanged)
return;
Vector<TextureMapperLayer*> children;
for (auto& child : state.children) {
TextureMapperLayer* childLayer = layerByID(child);
children.append(childLayer);
}
layer->setChildren(children);
}
void CoordinatedGraphicsScene::setLayerChildrenIfNeeded(TextureMapperLayer* layer, const CoordinatedGraphicsLayerState& state)
{
if (!state.childrenChanged)
return;
Vector<TextureMapperLayer*> children;
for (size_t i = 0; i < state.children.size(); ++i) {
CoordinatedLayerID childID = state.children[i];
TextureMapperLayer* child = layerByID(childID);
children.append(child);
}
layer->setChildren(children);
}
void LayerTreeHostProxy::updateTile(WebLayerID layerID, int tileID, const IntRect& sourceRect, const IntRect& targetRect, const QImage& image)
{
ensureLayer(layerID);
TextureMapperNode* node = toTextureMapperNode(layerByID(layerID));
if (!node)
return;
int nodeTileID = remoteTileIDToNodeTileID(tileID);
if (!nodeTileID)
return;
QImage imageRef(image);
node->setTextureMapper(m_textureMapper.get());
node->setContentsTileBackBuffer(nodeTileID, sourceRect, targetRect, imageRef.bits(), BitmapTexture::BGRAFormat);
}
void LayerTreeHostProxy::setRootLayerID(WebLayerID layerID)
{
if (layerID == m_rootLayerID)
return;
m_rootLayerID = layerID;
m_rootLayer->removeAllChildren();
if (!layerID)
return;
GraphicsLayer* layer = layerByID(layerID);
if (!layer)
return;
m_rootLayer->addChild(layer);
}
void LayerTreeHostProxy::syncLayerParameters(const WebLayerInfo& layerInfo)
{
WebLayerID id = layerInfo.id;
ensureLayer(id);
LayerMap::iterator it = m_layers.find(id);
GraphicsLayer* layer = it->second;
layer->setName(layerInfo.name);
layer->setReplicatedByLayer(layerByID(layerInfo.replica));
layer->setMaskLayer(layerByID(layerInfo.mask));
layer->setPosition(layerInfo.pos);
layer->setSize(layerInfo.size);
layer->setTransform(layerInfo.transform);
layer->setAnchorPoint(layerInfo.anchorPoint);
layer->setChildrenTransform(layerInfo.childrenTransform);
layer->setBackfaceVisibility(layerInfo.backfaceVisible);
layer->setContentsOpaque(layerInfo.contentsOpaque);
layer->setContentsRect(layerInfo.contentsRect);
layer->setDrawsContent(layerInfo.drawsContent);
if (layerInfo.imageIsUpdated)
assignImageToLayer(layer, layerInfo.imageBackingStoreID);
// Never make the root layer clip.
layer->setMasksToBounds(layerInfo.isRootLayer ? false : layerInfo.masksToBounds);
layer->setOpacity(layerInfo.opacity);
layer->setPreserves3D(layerInfo.preserves3D);
Vector<GraphicsLayer*> children;
for (size_t i = 0; i < layerInfo.children.size(); ++i) {
WebLayerID childID = layerInfo.children[i];
GraphicsLayer* child = layerByID(childID);
if (!child) {
child = createLayer(childID).leakPtr();
m_layers.add(childID, child);
}
children.append(child);
}
layer->setChildren(children);
for (size_t i = 0; i < layerInfo.animations.size(); ++i) {
const WebKit::WebLayerAnimation anim = layerInfo.animations[i];
switch (anim.operation) {
case WebKit::WebLayerAnimation::AddAnimation: {
const IntSize boxSize = anim.boxSize;
double offset = WTF::currentTime() - anim.startTime;
layer->addAnimation(anim.keyframeList, boxSize, anim.animation.get(), anim.name, offset);
break;
}
case WebKit::WebLayerAnimation::RemoveAnimation:
layer->removeAnimation(anim.name);
break;
case WebKit::WebLayerAnimation::PauseAnimation:
double offset = WTF::currentTime() - anim.startTime;
layer->pauseAnimation(anim.name, offset);
break;
}
}
if (layerInfo.isRootLayer && m_rootLayerID != id)
setRootLayerID(id);
}
TextureMapperLayer* CoordinatedGraphicsScene::getLayerByIDIfExists(CoordinatedLayerID id)
{
return (id != InvalidCoordinatedLayerID) ? layerByID(id) : 0;
}
void CoordinatedGraphicsScene::setLayerState(CoordinatedLayerID id, const CoordinatedGraphicsLayerState& layerState)
{
ASSERT(m_rootLayerID != InvalidCoordinatedLayerID);
TextureMapperLayer* layer = layerByID(id);
if (layerState.positionChanged)
layer->setPosition(layerState.pos);
if (layerState.anchorPointChanged)
layer->setAnchorPoint(layerState.anchorPoint);
if (layerState.sizeChanged)
layer->setSize(layerState.size);
if (layerState.transformChanged)
layer->setTransform(layerState.transform);
if (layerState.childrenTransformChanged)
layer->setChildrenTransform(layerState.childrenTransform);
if (layerState.contentsRectChanged)
layer->setContentsRect(layerState.contentsRect);
if (layerState.contentsTilingChanged) {
layer->setContentsTilePhase(layerState.contentsTilePhase);
layer->setContentsTileSize(layerState.contentsTileSize);
}
if (layerState.opacityChanged)
layer->setOpacity(layerState.opacity);
if (layerState.solidColorChanged)
layer->setSolidColor(layerState.solidColor);
if (layerState.debugBorderColorChanged || layerState.debugBorderWidthChanged)
layer->setDebugVisuals(layerState.showDebugBorders, layerState.debugBorderColor, layerState.debugBorderWidth, layerState.showRepaintCounter);
if (layerState.replicaChanged)
layer->setReplicaLayer(getLayerByIDIfExists(layerState.replica));
if (layerState.maskChanged)
layer->setMaskLayer(getLayerByIDIfExists(layerState.mask));
if (layerState.imageChanged)
assignImageBackingToLayer(layer, layerState.imageID);
if (layerState.flagsChanged) {
layer->setContentsOpaque(layerState.contentsOpaque);
layer->setDrawsContent(layerState.drawsContent);
layer->setContentsVisible(layerState.contentsVisible);
layer->setBackfaceVisibility(layerState.backfaceVisible);
// Never clip the root layer.
layer->setMasksToBounds(id == m_rootLayerID ? false : layerState.masksToBounds);
layer->setPreserves3D(layerState.preserves3D);
bool fixedToViewportChanged = layer->fixedToViewport() != layerState.fixedToViewport;
layer->setFixedToViewport(layerState.fixedToViewport);
if (fixedToViewportChanged) {
if (layerState.fixedToViewport)
m_fixedLayers.add(id, layer);
else
m_fixedLayers.remove(id);
}
layer->setIsScrollable(layerState.isScrollable);
}
if (layerState.committedScrollOffsetChanged)
layer->didCommitScrollOffset(layerState.committedScrollOffset);
prepareContentBackingStore(layer);
// Apply Operations.
setLayerChildrenIfNeeded(layer, layerState);
createTilesIfNeeded(layer, layerState);
removeTilesIfNeeded(layer, layerState);
updateTilesIfNeeded(layer, layerState);
setLayerFiltersIfNeeded(layer, layerState);
setLayerAnimationsIfNeeded(layer, layerState);
#if USE(GRAPHICS_SURFACE)
syncPlatformLayerIfNeeded(layer, layerState);
#endif
setLayerRepaintCountIfNeeded(layer, layerState);
}