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();
}
bool WebGraphicsLayer::setChildren(const Vector<GraphicsLayer*>& children)
{
bool ok = GraphicsLayer::setChildren(children);
if (!ok)
return false;
for (int i = 0; i < children.size(); ++i) {
WebGraphicsLayer* child = toWebGraphicsLayer(children[i]);
child->setContentsScale(m_contentsScale);
child->notifyChange();
}
notifyChange();
return true;
}
bool WebGraphicsLayer::setChildren(const Vector<GraphicsLayer*>& children)
{
bool ok = GraphicsLayer::setChildren(children);
if (!ok)
return false;
for (int i = 0; i < children.size(); ++i) {
WebGraphicsLayer* child = toWebGraphicsLayer(children[i]);
child->setWebGraphicsLayerClient(m_webGraphicsLayerClient);
child->didChangeLayerState();
}
didChangeChildren();
return true;
}
WebLayerTreeTileClient* WebGraphicsLayer::layerTreeTileClient() const
{
if (m_layerTreeTileClient)
return m_layerTreeTileClient;
WebGraphicsLayer* parent;
if (this->replicatedLayer())
parent = toWebGraphicsLayer(this->replicatedLayer());
else if (this->maskTarget())
parent = toWebGraphicsLayer(this->maskTarget());
else
parent = toWebGraphicsLayer(this->parent());
if (!parent)
return 0;
return parent->layerTreeTileClient();
}
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::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();
}
LayerTreeHostQt::LayerTreeHostQt(WebPage* webPage)
: LayerTreeHost(webPage)
, m_notifyAfterScheduledLayerFlush(false)
, m_isValid(true)
#if USE(TILED_BACKING_STORE)
, m_waitingForUIProcess(false)
, m_isSuspended(false)
, m_contentsScale(1)
#endif
, m_shouldSyncFrame(false)
, m_shouldSyncRootLayer(true)
, m_layerFlushTimer(this, &LayerTreeHostQt::layerFlushTimerFired)
, m_layerFlushSchedulingEnabled(true)
{
// Create a root layer.
m_rootLayer = GraphicsLayer::create(this);
WebGraphicsLayer* webRootLayer = toWebGraphicsLayer(m_rootLayer.get());
webRootLayer->setRootLayer(true);
#ifndef NDEBUG
m_rootLayer->setName("LayerTreeHostQt root layer");
#endif
m_rootLayer->setDrawsContent(false);
m_rootLayer->setSize(m_webPage->size());
m_layerTreeContext.webLayerID = toWebGraphicsLayer(webRootLayer)->id();
m_nonCompositedContentLayer = GraphicsLayer::create(this);
#if USE(TILED_BACKING_STORE)
toWebGraphicsLayer(m_rootLayer.get())->setWebGraphicsLayerClient(this);
#endif
#ifndef NDEBUG
m_nonCompositedContentLayer->setName("LayerTreeHostQt non-composited content");
#endif
m_nonCompositedContentLayer->setDrawsContent(true);
m_nonCompositedContentLayer->setSize(m_webPage->size());
m_rootLayer->addChild(m_nonCompositedContentLayer.get());
if (m_webPage->hasPageOverlay())
createPageOverlayLayer();
scheduleLayerFlush();
}
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 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);
}