void WebGraphicsLayer::setVisibleContentRect(const IntRect& rect)
{
m_visibleContentRect = rect;
notifyChange();
m_mainBackingStore->adjustVisibleRect();
if (maskLayer())
toWebGraphicsLayer(maskLayer())->setVisibleContentRect(rect);
}
/* \reimp (GraphicsLayer.h)
*/
void GraphicsLayerTextureMapper::setContentsVisible(bool value)
{
if (value == contentsAreVisible())
return;
notifyChange(TextureMapperLayer::ContentsVisibleChange);
GraphicsLayer::setContentsVisible(value);
if (maskLayer())
maskLayer()->setContentsVisible(value);
}
/* \reimp (GraphicsLayer.h)
*/
void GraphicsLayerTextureMapper::setSize(const FloatSize& value)
{
if (value == size())
return;
GraphicsLayer::setSize(value);
if (maskLayer())
maskLayer()->setSize(value);
notifyChange(TextureMapperLayer::SizeChange);
}
void WebGraphicsLayer::setSize(const FloatSize& size)
{
if (this->size() == size)
return;
GraphicsLayer::setSize(size);
setNeedsDisplay();
if (maskLayer())
maskLayer()->setSize(size);
notifyChange();
}
void CoordinatedGraphicsLayer::setSize(const FloatSize& size)
{
if (this->size() == size)
return;
GraphicsLayer::setSize(size);
m_layerState.sizeChanged = true;
if (maskLayer())
maskLayer()->setSize(size);
didChangeGeometry();
}
void CoordinatedGraphicsLayer::setContentsVisible(bool b)
{
if (contentsAreVisible() == b)
return;
GraphicsLayer::setContentsVisible(b);
m_layerState.contentsVisible = b;
m_layerState.flagsChanged = true;
if (maskLayer())
maskLayer()->setContentsVisible(b);
didChangeLayerState();
}
void CoordinatedGraphicsLayer::syncPendingStateChangesIncludingSubLayers()
{
if (m_layerState.hasPendingChanges()) {
m_coordinator->syncLayerState(m_id, m_layerState);
resetLayerState();
}
if (maskLayer())
toCoordinatedGraphicsLayer(maskLayer())->syncPendingStateChangesIncludingSubLayers();
for (auto& child : children())
toCoordinatedGraphicsLayer(child)->syncPendingStateChangesIncludingSubLayers();
}
/* \reimp (GraphicsLayer.h)
*/
void GraphicsLayerTextureMapper::flushCompositingState(const FloatRect& rect)
{
if (!m_layer->textureMapper())
return;
flushCompositingStateForThisLayerOnly();
if (maskLayer())
maskLayer()->flushCompositingState(rect);
if (replicaLayer())
replicaLayer()->flushCompositingState(rect);
for (size_t i = 0; i < children().size(); ++i)
children()[i]->flushCompositingState(rect);
}
void GraphicsLayerTextureMapper::flushCompositingState(const FloatRect& rect, bool viewportIsStable)
{
if (!m_layer.textureMapper())
return;
flushCompositingStateForThisLayerOnly(viewportIsStable);
if (maskLayer())
maskLayer()->flushCompositingState(rect, viewportIsStable);
if (replicaLayer())
replicaLayer()->flushCompositingState(rect, viewportIsStable);
for (auto* child : children())
child->flushCompositingState(rect, viewportIsStable);
}
void GraphicsLayerTextureMapper::updateBackingStoreIncludingSubLayers()
{
if (!m_layer.textureMapper())
return;
updateBackingStoreIfNeeded();
if (maskLayer())
downcast<GraphicsLayerTextureMapper>(*maskLayer()).updateBackingStoreIfNeeded();
if (replicaLayer())
downcast<GraphicsLayerTextureMapper>(*replicaLayer()).updateBackingStoreIfNeeded();
for (auto* child : children())
downcast<GraphicsLayerTextureMapper>(*child).updateBackingStoreIncludingSubLayers();
}
/* \reimp (GraphicsLayer.h)
*/
void GraphicsLayerTextureMapper::setMaskLayer(GraphicsLayer* value)
{
if (value == maskLayer())
return;
GraphicsLayer::setMaskLayer(value);
notifyChange(TextureMapperNode::MaskLayerChange);
}
void CoordinatedGraphicsLayer::syncLayerState()
{
if (!m_shouldSyncLayerState)
return;
m_shouldSyncLayerState = false;
m_layerState.childrenTransform = childrenTransform();
m_layerState.contentsRect = contentsRect();
m_layerState.mask = toCoordinatedLayerID(maskLayer());
m_layerState.opacity = opacity();
m_layerState.replica = toCoordinatedLayerID(replicaLayer());
m_layerState.transform = transform();
m_layerState.anchorPoint = m_adjustedAnchorPoint;
m_layerState.pos = m_adjustedPosition;
m_layerState.size = m_adjustedSize;
if (m_layerState.flagsChanged) {
m_layerState.drawsContent = drawsContent();
m_layerState.contentsVisible = contentsAreVisible();
m_layerState.backfaceVisible = backfaceVisibility();
m_layerState.masksToBounds = masksToBounds();
m_layerState.preserves3D = preserves3D();
m_layerState.fixedToViewport = fixedToViewport();
m_layerState.showDebugBorders = isShowingDebugBorder();
m_layerState.showRepaintCounter = isShowingRepaintCounter();
m_layerState.isScrollable = isScrollable();
}
if (m_layerState.showDebugBorders)
updateDebugIndicators();
}
void WebGraphicsLayer::updateTileBuffersRecursively()
{
m_mainBackingStore->updateTileBuffers();
for (size_t i = 0; i < children().size(); ++i) {
WebGraphicsLayer* layer = toWebGraphicsLayer(this->children()[i]);
layer->updateTileBuffersRecursively();
}
if (WebGraphicsLayer* mask = toWebGraphicsLayer(maskLayer()))
mask->updateTileBuffersRecursively();
}
/* \reimp (GraphicsLayer.h)
*/
void GraphicsLayerTextureMapper::setMaskLayer(GraphicsLayer* value)
{
if (value == maskLayer())
return;
GraphicsLayer::setMaskLayer(value);
notifyChange(TextureMapperLayer::MaskLayerChange);
if (!value)
return;
value->setSize(size());
value->setContentsVisible(contentsAreVisible());
}
void WebGraphicsLayer::syncCompositingState(const FloatRect& rect)
{
for (size_t i = 0; i < children().size(); ++i)
children()[i]->syncCompositingState(rect);
if (WebGraphicsLayer* mask = toWebGraphicsLayer(maskLayer()))
mask->syncCompositingStateForThisLayerOnly();
if (WebGraphicsLayer* replica = toWebGraphicsLayer(replicaLayer()))
replica->syncCompositingStateForThisLayerOnly();
syncCompositingStateForThisLayerOnly();
}
void CoordinatedGraphicsLayer::updateContentBuffersIncludingSubLayers()
{
if (CoordinatedGraphicsLayer* mask = toCoordinatedGraphicsLayer(maskLayer()))
mask->updateContentBuffers();
if (CoordinatedGraphicsLayer* replica = toCoordinatedGraphicsLayer(replicaLayer()))
replica->updateContentBuffers();
updateContentBuffers();
for (auto& child : children())
toCoordinatedGraphicsLayer(child)->updateContentBuffersIncludingSubLayers();
}
void CoordinatedGraphicsLayer::updateContentBuffersIncludingSubLayers()
{
if (CoordinatedGraphicsLayer* mask = toCoordinatedGraphicsLayer(maskLayer()))
mask->updateContentBuffers();
if (CoordinatedGraphicsLayer* replica = toCoordinatedGraphicsLayer(replicaLayer()))
replica->updateContentBuffers();
updateContentBuffers();
for (size_t i = 0; i < children().size(); ++i)
toCoordinatedGraphicsLayer(children()[i])->updateContentBuffersIncludingSubLayers();
}
void CoordinatedGraphicsLayer::flushCompositingState(const FloatRect& rect)
{
if (notifyFlushRequired())
return;
if (CoordinatedGraphicsLayer* mask = toCoordinatedGraphicsLayer(maskLayer()))
mask->flushCompositingStateForThisLayerOnly();
if (CoordinatedGraphicsLayer* replica = toCoordinatedGraphicsLayer(replicaLayer()))
replica->flushCompositingStateForThisLayerOnly();
flushCompositingStateForThisLayerOnly();
for (size_t i = 0; i < children().size(); ++i)
children()[i]->flushCompositingState(rect);
}
void CoordinatedGraphicsLayer::flushCompositingState(const FloatRect& rect, bool viewportIsStable)
{
if (notifyFlushRequired())
return;
if (CoordinatedGraphicsLayer* mask = toCoordinatedGraphicsLayer(maskLayer()))
mask->flushCompositingStateForThisLayerOnly(viewportIsStable);
if (CoordinatedGraphicsLayer* replica = toCoordinatedGraphicsLayer(replicaLayer()))
replica->flushCompositingStateForThisLayerOnly(viewportIsStable);
flushCompositingStateForThisLayerOnly(viewportIsStable);
for (auto& child : children())
child->flushCompositingState(rect, viewportIsStable);
}
void WebGraphicsLayer::recreateBackingStoreIfNeeded()
{
for (size_t i = 0; i < children().size(); ++i) {
WebGraphicsLayer* layer = toWebGraphicsLayer(this->children()[i]);
layer->recreateBackingStoreIfNeeded();
}
if (WebGraphicsLayer* mask = toWebGraphicsLayer(maskLayer()))
mask->recreateBackingStoreIfNeeded();
if (!m_mainBackingStore) {
m_mainBackingStore = adoptPtr(new TiledBackingStore(this, TiledBackingStoreRemoteTileBackend::create(this)));
m_mainBackingStore->setContentsScale(m_contentsScale);
}
if (m_image)
setContentsNeedsDisplay();
}
void WebGraphicsLayer::setMaskLayer(GraphicsLayer* layer)
{
if (layer == maskLayer())
return;
GraphicsLayer::setMaskLayer(layer);
if (!layer)
return;
layer->setSize(size());
WebGraphicsLayer* webGraphicsLayer = toWebGraphicsLayer(layer);
webGraphicsLayer->setWebGraphicsLayerClient(m_webGraphicsLayerClient);
webGraphicsLayer->setMaskTarget(this);
webGraphicsLayer->didChangeLayerState();
didChangeLayerState();
}
void WebGraphicsLayer::syncCompositingStateForThisLayerOnly()
{
if (!m_layerTreeTileClient)
m_layerTreeTileClient = layerTreeTileClient();
updateContentBuffers();
if (!m_modified)
return;
m_layerInfo.name = name();
m_layerInfo.anchorPoint = anchorPoint();
m_layerInfo.backfaceVisible = backfaceVisibility();
m_layerInfo.childrenTransform = childrenTransform();
m_layerInfo.contentsOpaque = contentsOpaque();
m_layerInfo.contentsRect = contentsRect();
m_layerInfo.drawsContent = drawsContent();
m_layerInfo.mask = toWebLayerID(maskLayer());
m_layerInfo.masksToBounds = masksToBounds();
m_layerInfo.opacity = opacity();
m_layerInfo.parent = toWebLayerID(parent());
m_layerInfo.pos = position();
m_layerInfo.preserves3D = preserves3D();
m_layerInfo.replica = toWebLayerID(replicaLayer());
m_layerInfo.size = size();
m_layerInfo.transform = transform();
m_contentNeedsDisplay = false;
m_layerInfo.children.clear();
for (size_t i = 0; i < children().size(); ++i)
m_layerInfo.children.append(toWebLayerID(children()[i]));
ASSERT(m_layerTreeTileClient);
if (m_layerInfo.imageIsUpdated && m_image && !m_layerInfo.imageBackingStoreID)
m_layerInfo.imageBackingStoreID = m_layerTreeTileClient->adoptImageBackingStore(m_image.get());
m_layerTreeTileClient->didSyncCompositingStateForLayer(m_layerInfo);
m_modified = false;
m_layerInfo.imageIsUpdated = false;
if (m_hasPendingAnimations)
notifyAnimationStarted(WTF::currentTime());
m_layerInfo.animations.clear();
m_hasPendingAnimations = false;
}
void CoordinatedGraphicsLayer::flushCompositingState(const FloatRect& rect)
{
if (!m_coordinator->isFlushingLayerChanges()) {
if (client())
client()->notifyFlushRequired(this);
return;
}
if (CoordinatedGraphicsLayer* mask = toCoordinatedGraphicsLayer(maskLayer()))
mask->flushCompositingStateForThisLayerOnly();
if (CoordinatedGraphicsLayer* replica = toCoordinatedGraphicsLayer(replicaLayer()))
replica->flushCompositingStateForThisLayerOnly();
flushCompositingStateForThisLayerOnly();
for (size_t i = 0; i < children().size(); ++i)
children()[i]->flushCompositingState(rect);
}
void WebGraphicsLayer::setLayerTreeTileClient(WebKit::WebLayerTreeTileClient* client)
{
if (m_layerTreeTileClient == client)
return;
if (WebGraphicsLayer* replica = toWebGraphicsLayer(replicaLayer()))
replica->setLayerTreeTileClient(client);
if (WebGraphicsLayer* mask = toWebGraphicsLayer(maskLayer()))
mask->setLayerTreeTileClient(client);
for (size_t i = 0; i < children().size(); ++i) {
WebGraphicsLayer* layer = toWebGraphicsLayer(this->children()[i]);
layer->setLayerTreeTileClient(client);
}
// Have to force detach from remote layer here if layer tile client changes.
if (m_layerTreeTileClient)
m_layerTreeTileClient->didDeleteLayer(id());
m_layerTreeTileClient = client;
}
void WebGraphicsLayer::purgeBackingStores()
{
for (size_t i = 0; i < children().size(); ++i) {
WebGraphicsLayer* layer = toWebGraphicsLayer(this->children()[i]);
layer->purgeBackingStores();
}
if (WebGraphicsLayer* mask = toWebGraphicsLayer(maskLayer()))
mask->purgeBackingStores();
if (m_mainBackingStore)
m_mainBackingStore.clear();
if (!m_layerInfo.imageBackingStoreID)
return;
layerTreeTileClient()->releaseImageBackingStore(m_layerInfo.imageBackingStoreID);
m_layerInfo.imageBackingStoreID = 0;
}
void WebGraphicsLayer::setMaskLayer(GraphicsLayer* layer)
{
if (layer == maskLayer())
return;
GraphicsLayer::setMaskLayer(layer);
if (!layer)
return;
layer->setSize(size());
WebGraphicsLayer* webGraphicsLayer = toWebGraphicsLayer(layer);
webGraphicsLayer->setLayerTreeTileClient(layerTreeTileClient());
webGraphicsLayer->setMaskTarget(this);
webGraphicsLayer->setContentsScale(m_contentsScale);
webGraphicsLayer->notifyChange();
notifyChange();
}
void WebGraphicsLayer::setContentsScale(float scale)
{
for (size_t i = 0; i < children().size(); ++i) {
WebGraphicsLayer* layer = toWebGraphicsLayer(this->children()[i]);
layer->setContentsScale(scale);
}
if (WebGraphicsLayer* mask = toWebGraphicsLayer(maskLayer()))
mask->setContentsScale(scale);
m_contentsScale = scale;
if (m_mainBackingStore && m_mainBackingStore->contentsScale() == scale)
return;
notifyChange();
m_previousBackingStore = m_mainBackingStore.release();
m_mainBackingStore = adoptPtr(new TiledBackingStore(this, TiledBackingStoreRemoteTileBackend::create(this)));
m_mainBackingStore->setContentsScale(scale);
}
void CoordinatedGraphicsLayer::setMaskLayer(GraphicsLayer* layer)
{
if (layer == maskLayer())
return;
GraphicsLayer::setMaskLayer(layer);
if (!layer)
return;
layer->setSize(size());
layer->setContentsVisible(contentsAreVisible());
CoordinatedGraphicsLayer* coordinatedLayer = toCoordinatedGraphicsLayer(layer);
coordinatedLayer->didChangeLayerState();
m_layerState.mask = coordinatedLayer->id();
m_layerState.maskChanged = true;
didChangeLayerState();
}
void WebGraphicsLayer::syncLayerState()
{
if (!m_shouldSyncLayerState)
return;
m_shouldSyncLayerState = false;
m_layerInfo.anchorPoint = anchorPoint();
m_layerInfo.backfaceVisible = backfaceVisibility();
m_layerInfo.childrenTransform = childrenTransform();
m_layerInfo.contentsOpaque = contentsOpaque();
m_layerInfo.contentsRect = contentsRect();
m_layerInfo.drawsContent = drawsContent();
m_layerInfo.mask = toWebLayerID(maskLayer());
m_layerInfo.masksToBounds = masksToBounds();
m_layerInfo.opacity = opacity();
m_layerInfo.parent = toWebLayerID(parent());
m_layerInfo.pos = position();
m_layerInfo.preserves3D = preserves3D();
m_layerInfo.replica = toWebLayerID(replicaLayer());
m_layerInfo.size = size();
m_layerInfo.transform = transform();
m_webGraphicsLayerClient->syncLayerState(m_id, m_layerInfo);
}
void WebGraphicsLayer::setWebGraphicsLayerClient(WebKit::WebGraphicsLayerClient* client)
{
if (m_webGraphicsLayerClient == client)
return;
if (WebGraphicsLayer* replica = toWebGraphicsLayer(replicaLayer()))
replica->setWebGraphicsLayerClient(client);
if (WebGraphicsLayer* mask = toWebGraphicsLayer(maskLayer()))
mask->setWebGraphicsLayerClient(client);
for (size_t i = 0; i < children().size(); ++i) {
WebGraphicsLayer* layer = toWebGraphicsLayer(this->children()[i]);
layer->setWebGraphicsLayerClient(client);
}
// We have to release resources on the UI process here if the remote client has changed or is removed.
if (m_webGraphicsLayerClient) {
purgeBackingStores();
m_webGraphicsLayerClient->detachLayer(this);
}
m_webGraphicsLayerClient = client;
if (client)
client->attachLayer(this);
}