LayerTreeHostQt::LayerTreeHostQt(WebPage* webPage)
: LayerTreeHost(webPage)
, m_notifyAfterScheduledLayerFlush(false)
, m_isValid(true)
, m_layerFlushTimer(this, &LayerTreeHostQt::layerFlushTimerFired)
, m_layerFlushSchedulingEnabled(true)
{
// Create a root layer.
m_rootLayer = GraphicsLayer::create(this);
#ifndef NDEBUG
m_rootLayer->setName("LayerTreeHostQt root layer");
#endif
m_rootLayer->setDrawsContent(false);
m_rootLayer->setSize(m_webPage->size());
m_layerTreeContext.webLayerID = toWebGraphicsLayer(m_rootLayer.get())->id();
m_nonCompositedContentLayer = GraphicsLayer::create(this);
#ifndef NDEBUG
m_nonCompositedContentLayer->setName("LayerTreeHostQt non-composited content");
#endif
m_nonCompositedContentLayer->setDrawsContent(true);
m_nonCompositedContentLayer->setContentsOpaque(m_webPage->drawsBackground() && !m_webPage->drawsTransparentBackground());
m_nonCompositedContentLayer->setSize(m_webPage->size());
m_rootLayer->addChild(m_nonCompositedContentLayer.get());
if (m_webPage->hasPageOverlay())
createPageOverlayLayer();
scheduleLayerFlush();
}
void LayerTreeCoordinator::renderNextFrame()
{
m_waitingForUIProcess = false;
scheduleLayerFlush();
for (unsigned i = 0; i < m_updateAtlases.size(); ++i)
m_updateAtlases[i]->didSwapBuffers();
}
void LayerTreeHostGtk::initialize()
{
m_rootLayer = GraphicsLayer::create(graphicsLayerFactory(), *this);
m_rootLayer->setDrawsContent(false);
m_rootLayer->setSize(m_webPage->size());
// The non-composited contents are a child of the root layer.
m_nonCompositedContentLayer = GraphicsLayer::create(graphicsLayerFactory(), *this);
m_nonCompositedContentLayer->setDrawsContent(true);
m_nonCompositedContentLayer->setContentsOpaque(m_webPage->drawsBackground() && !m_webPage->drawsTransparentBackground());
m_nonCompositedContentLayer->setSize(m_webPage->size());
if (m_webPage->corePage()->settings().acceleratedDrawingEnabled())
m_nonCompositedContentLayer->setAcceleratesDrawing(true);
#ifndef NDEBUG
m_rootLayer->setName("LayerTreeHost root layer");
m_nonCompositedContentLayer->setName("LayerTreeHost non-composited content");
#endif
m_rootLayer->addChild(m_nonCompositedContentLayer.get());
m_nonCompositedContentLayer->setNeedsDisplay();
// The creation of the TextureMapper needs an active OpenGL context.
if (!makeContextCurrent())
return;
ensureTextureMapper();
scheduleLayerFlush();
}
void LayerTreeCoordinator::detachLayer(CoordinatedGraphicsLayer* layer)
{
m_registeredLayers.remove(layer);
m_shouldSyncFrame = true;
m_detachedLayers.append(layer->id());
scheduleLayerFlush();
}
void LayerTreeHostCA::initialize()
{
// Create a root layer.
m_rootLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
#ifndef NDEBUG
m_rootLayer->setName("LayerTreeHost root layer");
#endif
m_rootLayer->setDrawsContent(false);
m_rootLayer->setSize(m_webPage->size());
static_cast<GraphicsLayerCA*>(m_rootLayer.get())->platformCALayer()->setGeometryFlipped(true);
m_nonCompositedContentLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
static_cast<GraphicsLayerCA*>(m_nonCompositedContentLayer.get())->setAllowTiledLayer(false);
#ifndef NDEBUG
m_nonCompositedContentLayer->setName("LayerTreeHost non-composited content");
#endif
m_nonCompositedContentLayer->setDrawsContent(true);
m_nonCompositedContentLayer->setContentsOpaque(m_webPage->drawsBackground() && !m_webPage->drawsTransparentBackground());
m_nonCompositedContentLayer->setSize(m_webPage->size());
if (m_webPage->corePage()->settings()->acceleratedDrawingEnabled())
m_nonCompositedContentLayer->setAcceleratesDrawing(true);
m_rootLayer->addChild(m_nonCompositedContentLayer.get());
if (m_webPage->hasPageOverlay())
createPageOverlayLayer();
platformInitialize();
setLayerFlushSchedulingEnabled(!m_webPage->drawingArea() || !m_webPage->drawingArea()->layerTreeStateIsFrozen());
scheduleLayerFlush();
}
void LayerTreeCoordinator::sizeDidChange(const WebCore::IntSize& newSize)
{
if (m_rootLayer->size() == newSize)
return;
m_rootLayer->setSize(newSize);
// If the newSize exposes new areas of the non-composited content a setNeedsDisplay is needed
// for those newly exposed areas.
FloatSize oldSize = m_nonCompositedContentLayer->size();
m_nonCompositedContentLayer->setSize(newSize);
if (newSize.width() > oldSize.width()) {
float height = std::min(static_cast<float>(newSize.height()), oldSize.height());
m_nonCompositedContentLayer->setNeedsDisplayInRect(FloatRect(oldSize.width(), 0, newSize.width() - oldSize.width(), height));
}
if (newSize.height() > oldSize.height())
m_nonCompositedContentLayer->setNeedsDisplayInRect(FloatRect(0, oldSize.height(), newSize.width(), newSize.height() - oldSize.height()));
if (m_pageOverlayLayer)
m_pageOverlayLayer->setSize(newSize);
scheduleLayerFlush();
}
void LayerTreeCoordinator::setVisibleContentsRect(const IntRect& rect, float scale, const FloatPoint& trajectoryVector)
{
bool contentsRectDidChange = rect != m_visibleContentsRect;
bool contentsScaleDidChange = scale != m_contentsScale;
// A zero trajectoryVector indicates that tiles all around the viewport are requested.
toCoordinatedGraphicsLayer(m_nonCompositedContentLayer.get())->setVisibleContentRectTrajectoryVector(trajectoryVector);
if (contentsRectDidChange || contentsScaleDidChange) {
m_visibleContentsRect = rect;
m_contentsScale = scale;
HashSet<WebCore::CoordinatedGraphicsLayer*>::iterator end = m_registeredLayers.end();
for (HashSet<WebCore::CoordinatedGraphicsLayer*>::iterator it = m_registeredLayers.begin(); it != end; ++it) {
if (contentsScaleDidChange)
(*it)->setContentsScale(scale);
if (contentsRectDidChange)
(*it)->adjustVisibleRect();
}
}
scheduleLayerFlush();
if (m_webPage->useFixedLayout())
m_webPage->setFixedVisibleContentRect(rect);
if (contentsRectDidChange)
m_shouldSendScrollPositionUpdate = true;
}
void CoordinatedLayerTreeHost::didUninstallPageOverlay(PageOverlay*)
{
m_pageOverlay = 0;
destroyPageOverlayLayer();
scheduleLayerFlush();
}
void CoordinatedLayerTreeHost::setVisibleContentsRect(const FloatRect& rect, float scale, const FloatPoint& trajectoryVector)
{
bool contentsRectDidChange = rect != m_visibleContentsRect;
bool contentsScaleDidChange = scale != m_contentsScale;
// A zero trajectoryVector indicates that tiles all around the viewport are requested.
toCoordinatedGraphicsLayer(m_nonCompositedContentLayer.get())->setVisibleContentRectTrajectoryVector(trajectoryVector);
if (contentsRectDidChange || contentsScaleDidChange) {
m_visibleContentsRect = rect;
m_contentsScale = scale;
HashSet<WebCore::CoordinatedGraphicsLayer*>::iterator end = m_registeredLayers.end();
for (HashSet<WebCore::CoordinatedGraphicsLayer*>::iterator it = m_registeredLayers.begin(); it != end; ++it) {
if (contentsScaleDidChange)
(*it)->setContentsScale(scale);
if (contentsRectDidChange)
(*it)->setNeedsVisibleRectAdjustment();
}
}
scheduleLayerFlush();
if (m_webPage->useFixedLayout()) {
// Round the rect instead of enclosing it to make sure that its size stays
// the same while panning. This can have nasty effects on layout.
m_webPage->setFixedVisibleContentRect(roundedIntRect(rect));
}
if (contentsRectDidChange)
m_shouldSendScrollPositionUpdate = true;
}
void AcceleratedCompositingContext::initialize()
{
if (m_rootLayer)
return;
GtkAllocation allocation;
gtk_widget_get_allocation(GTK_WIDGET(m_webView), &allocation);
IntSize pageSize(allocation.width, allocation.height);
m_rootLayer = GraphicsLayer::create(0, this);
m_rootLayer->setDrawsContent(false);
m_rootLayer->setSize(pageSize);
// The non-composited contents are a child of the root layer.
m_nonCompositedContentLayer = GraphicsLayer::create(0, this);
m_nonCompositedContentLayer->setDrawsContent(true);
m_nonCompositedContentLayer->setContentsOpaque(!m_webView->priv->transparent);
m_nonCompositedContentLayer->setSize(pageSize);
if (core(m_webView)->settings()->acceleratedDrawingEnabled())
m_nonCompositedContentLayer->setAcceleratesDrawing(true);
#ifndef NDEBUG
m_rootLayer->setName("Root layer");
m_nonCompositedContentLayer->setName("Non-composited content");
#endif
m_rootLayer->addChild(m_nonCompositedContentLayer.get());
m_nonCompositedContentLayer->setNeedsDisplay();
scheduleLayerFlush();
}
void AcceleratedCompositingContext::resizeRootLayer(const IntSize& newSize)
{
if (!m_rootLayerEmbedder)
return;
if (m_rootLayer->size() == newSize)
return;
GtkAllocation allocation;
allocation.x = 0;
allocation.y = 0;
allocation.width = newSize.width();
allocation.height = newSize.height();
gtk_widget_size_allocate(GTK_WIDGET(m_rootLayerEmbedder), &allocation);
m_rootLayer->setSize(newSize);
// If the newSize exposes new areas of the non-composited content a setNeedsDisplay is needed
// for those newly exposed areas.
FloatSize oldSize = m_nonCompositedContentLayer->size();
m_nonCompositedContentLayer->setSize(newSize);
if (newSize.width() > oldSize.width()) {
float height = std::min(static_cast<float>(newSize.height()), oldSize.height());
m_nonCompositedContentLayer->setNeedsDisplayInRect(FloatRect(oldSize.width(), 0, newSize.width() - oldSize.width(), height));
}
if (newSize.height() > oldSize.height())
m_nonCompositedContentLayer->setNeedsDisplayInRect(FloatRect(0, oldSize.height(), newSize.width(), newSize.height() - oldSize.height()));
m_nonCompositedContentLayer->setNeedsDisplayInRect(IntRect(IntPoint(), newSize));
scheduleLayerFlush();
}
void CoordinatedLayerTreeHost::scrollNonCompositedContents(const WebCore::IntRect&)
{
if (!m_webPage->useFixedLayout())
setNonCompositedContentsNeedDisplay();
scheduleLayerFlush();
}
void CoordinatedLayerTreeHost::setNonCompositedContentsNeedDisplay()
{
m_nonCompositedContentLayer->setNeedsDisplay();
if (m_pageOverlayLayer)
m_pageOverlayLayer->setNeedsDisplay();
scheduleLayerFlush();
}
void LayerTreeCoordinator::setNonCompositedContentsNeedDisplay(const WebCore::IntRect& rect)
{
m_nonCompositedContentLayer->setNeedsDisplayInRect(rect);
if (m_pageOverlayLayer)
m_pageOverlayLayer->setNeedsDisplayInRect(rect);
scheduleLayerFlush();
}
void CoordinatedLayerTreeHost::didInstallPageOverlay(PageOverlay* pageOverlay)
{
ASSERT(!m_pageOverlay);
m_pageOverlay = pageOverlay;
createPageOverlayLayer();
scheduleLayerFlush();
}
bool LayerTreeCoordinator::forceRepaintAsync(uint64_t callbackID)
{
// We expect the UI process to not require a new repaint until the previous one has finished.
ASSERT(!m_forceRepaintAsyncCallbackID);
m_forceRepaintAsyncCallbackID = callbackID;
scheduleLayerFlush();
return true;
}
void LayerTreeHostCA::setNonCompositedContentsNeedDisplay(const IntRect& rect)
{
m_nonCompositedContentLayer->setNeedsDisplayInRect(rect);
if (m_pageOverlayLayer)
m_pageOverlayLayer->setNeedsDisplayInRect(rect);
scheduleLayerFlush();
}
void LayerTreeHostGtk::setPageOverlayNeedsDisplay(PageOverlay* pageOverlay, const IntRect& rect)
{
GraphicsLayer* layer = m_pageOverlayLayers.get(pageOverlay);
if (!layer)
return;
layer->setNeedsDisplayInRect(rect);
scheduleLayerFlush();
}
PassOwnPtr<GraphicsLayer> CoordinatedLayerTreeHost::createGraphicsLayer(GraphicsLayerClient* client)
{
CoordinatedGraphicsLayer* layer = new CoordinatedGraphicsLayer(client);
layer->setCoordinator(this);
m_registeredLayers.add(layer->id(), layer);
m_layersToCreate.append(layer->id());
layer->setNeedsVisibleRectAdjustment();
scheduleLayerFlush();
return adoptPtr(layer);
}
void LayerTreeHostGtk::setRootCompositingLayer(GraphicsLayer* graphicsLayer)
{
m_nonCompositedContentLayer->removeAllChildren();
// Add the accelerated layer tree hierarchy.
if (graphicsLayer)
m_nonCompositedContentLayer->addChild(graphicsLayer);
scheduleLayerFlush();
}
void LayerTreeHostGtk::setNonCompositedContentsNeedDisplayInRect(const IntRect& rect)
{
m_nonCompositedContentLayer->setNeedsDisplayInRect(rect);
PageOverlayLayerMap::iterator end = m_pageOverlayLayers.end();
for (PageOverlayLayerMap::iterator it = m_pageOverlayLayers.begin(); it != end; ++it)
it->value->setNeedsDisplayInRect(rect);
scheduleLayerFlush();
}
void CoordinatedLayerTreeHost::scheduleAnimation()
{
if (m_isWaitingForRenderer)
return;
if (m_layerFlushTimer.isActive())
return;
m_layerFlushTimer.startOneShot(m_coordinator->nextAnimationServiceTime());
scheduleLayerFlush();
}
void LayerTreeHostCA::sizeDidChange(const IntSize& newSize)
{
m_rootLayer->setSize(newSize);
m_nonCompositedContentLayer->setSize(newSize);
if (m_pageOverlayLayer)
m_pageOverlayLayer->setSize(newSize);
scheduleLayerFlush();
flushPendingLayerChanges();
}
void LayerTreeCoordinator::forceRepaint()
{
// This is necessary for running layout tests. Since in this case we are not waiting for a UIProcess to reply nicely.
// Instead we are just triggering forceRepaint. But we still want to have the scripted animation callbacks being executed.
syncDisplayState();
// We need to schedule another flush, otherwise the forced paint might cancel a later expected flush.
// This is aligned with LayerTreeHostCA.
scheduleLayerFlush();
flushPendingLayerChanges();
}
CoordinatedLayerTreeHost::CoordinatedLayerTreeHost(WebPage* webPage)
: LayerTreeHost(webPage)
, m_notifyAfterScheduledLayerFlush(false)
, m_isValid(true)
, m_isPurging(false)
, m_isFlushingLayerChanges(false)
, m_waitingForUIProcess(true)
, m_isSuspended(false)
, m_shouldSyncFrame(false)
, m_didInitializeRootCompositingLayer(false)
, m_layerFlushTimer(this, &CoordinatedLayerTreeHost::layerFlushTimerFired)
, m_releaseInactiveAtlasesTimer(this, &CoordinatedLayerTreeHost::releaseInactiveAtlasesTimerFired)
, m_layerFlushSchedulingEnabled(true)
, m_forceRepaintAsyncCallbackID(0)
, m_animationsLocked(false)
{
m_webPage->corePage()->settings()->setScrollingCoordinatorEnabled(true);
m_webPage->corePage()->settings()->setApplyDeviceScaleFactorInCompositor(true);
// Create a root layer.
m_rootLayer = GraphicsLayer::create(this, this);
CoordinatedGraphicsLayer* coordinatedRootLayer = toCoordinatedGraphicsLayer(m_rootLayer.get());
#ifndef NDEBUG
m_rootLayer->setName("CoordinatedLayerTreeHost root layer");
#endif
m_rootLayer->setDrawsContent(false);
m_rootLayer->setSize(m_webPage->size());
m_layerTreeContext.coordinatedLayerID = toCoordinatedGraphicsLayer(coordinatedRootLayer)->id();
m_nonCompositedContentLayer = GraphicsLayer::create(this, this);
#ifndef NDEBUG
m_nonCompositedContentLayer->setName("CoordinatedLayerTreeHost non-composited content");
#endif
m_nonCompositedContentLayer->setDrawsContent(true);
m_nonCompositedContentLayer->setSize(m_webPage->size());
m_nonCompositedContentLayer->setShowDebugBorder(m_webPage->corePage()->settings()->showDebugBorders());
m_nonCompositedContentLayer->setShowRepaintCounter(m_webPage->corePage()->settings()->showRepaintCounter());
m_rootLayer->addChild(m_nonCompositedContentLayer.get());
CoordinatedSurface::setFactory(createCoordinatedSurface);
// This is a temporary way to enable this only in the GL case, until TextureMapperImageBuffer is removed.
// See https://bugs.webkit.org/show_bug.cgi?id=114869
CoordinatedGraphicsLayer::setShouldSupportContentsTiling(true);
if (m_webPage->hasPageOverlay())
createPageOverlayLayer();
scheduleLayerFlush();
}
void AcceleratedCompositingContext::setNonCompositedContentsNeedDisplay(const IntRect& rect)
{
if (!m_rootLayer)
return;
if (rect.isEmpty()) {
m_rootLayer->setNeedsDisplay();
return;
}
m_nonCompositedContentLayer->setNeedsDisplayInRect(rect);
scheduleLayerFlush();
}
void LayerTreeHostCAWin::setLayerFlushSchedulingEnabled(bool layerFlushingEnabled)
{
if (m_layerFlushSchedulingEnabled == layerFlushingEnabled)
return;
m_layerFlushSchedulingEnabled = layerFlushingEnabled;
if (m_layerFlushSchedulingEnabled) {
scheduleLayerFlush();
return;
}
LayerChangesFlusher::shared().cancelPendingFlush(this);
}
void LayerTreeCoordinator::setLayerFlushSchedulingEnabled(bool layerFlushingEnabled)
{
if (m_layerFlushSchedulingEnabled == layerFlushingEnabled)
return;
m_layerFlushSchedulingEnabled = layerFlushingEnabled;
if (m_layerFlushSchedulingEnabled) {
scheduleLayerFlush();
return;
}
cancelPendingLayerFlush();
}
void LayerTreeHostGtk::setNativeSurfaceHandleForCompositing(uint64_t handle)
{
m_layerTreeContext.contextID = handle;
// The creation of the TextureMapper needs an active OpenGL context.
if (!makeContextCurrent())
return;
ASSERT(m_isValid);
ASSERT(!m_textureMapper);
m_textureMapper = TextureMapper::create();
static_cast<TextureMapperGL*>(m_textureMapper.get())->setEnableEdgeDistanceAntialiasing(true);
downcast<GraphicsLayerTextureMapper>(*m_rootLayer).layer().setTextureMapper(m_textureMapper.get());
scheduleLayerFlush();
}
void ThreadedCoordinatedLayerTreeHost::setVisibleContentsRect(const FloatRect& rect, const FloatPoint& trajectoryVector, float scale)
{
m_coordinator->setVisibleContentsRect(rect, trajectoryVector);
if (m_lastScrollPosition != roundedIntPoint(rect.location())) {
m_lastScrollPosition = roundedIntPoint(rect.location());
if (!m_webPage->corePage()->mainFrame().view()->useFixedLayout())
m_webPage->corePage()->mainFrame().view()->notifyScrollPositionChanged(m_lastScrollPosition);
}
if (m_lastScaleFactor != scale) {
m_lastScaleFactor = scale;
didScaleFactorChanged(m_lastScaleFactor, m_lastScrollPosition);
}
scheduleLayerFlush();
}
