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(); }