void LayerTreeHostGtk::initialize()
{
m_rootLayer = GraphicsLayer::create(graphicsLayerFactory(), *this);
m_rootLayer->setDrawsContent(false);
m_rootLayer->setSize(m_webPage->size());
m_scaleMatrix.makeIdentity();
m_scaleMatrix.scale(m_webPage->deviceScaleFactor() * m_webPage->pageScaleFactor());
downcast<GraphicsLayerTextureMapper>(*m_rootLayer).layer().setAnchorPoint(FloatPoint3D());
downcast<GraphicsLayerTextureMapper>(*m_rootLayer).layer().setTransform(m_scaleMatrix);
// 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();
}
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 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 PaintLayerCompositor::ensureRootLayer()
{
RootLayerAttachment expectedAttachment = m_layoutView.frame()->isLocalRoot() ? RootLayerAttachedViaChromeClient : RootLayerAttachedViaEnclosingFrame;
if (expectedAttachment == m_rootLayerAttachment)
return;
Settings* settings = m_layoutView.document().settings();
if (!m_rootContentLayer) {
m_rootContentLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
IntRect overflowRect = m_layoutView.pixelSnappedLayoutOverflowRect();
m_rootContentLayer->setSize(FloatSize(overflowRect.maxX(), overflowRect.maxY()));
m_rootContentLayer->setPosition(FloatPoint());
m_rootContentLayer->setOwnerNodeId(DOMNodeIds::idForNode(m_layoutView.generatingNode()));
// FIXME: with rootLayerScrolls, we probably don't even need m_rootContentLayer?
if (!(settings && settings->rootLayerScrolls())) {
// Need to clip to prevent transformed content showing outside this frame
m_rootContentLayer->setMasksToBounds(true);
}
}
if (!m_overflowControlsHostLayer) {
ASSERT(!m_scrollLayer);
ASSERT(!m_containerLayer);
// Create a layer to host the clipping layer and the overflow controls layers.
m_overflowControlsHostLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
// Clip iframe's overflow controls layer.
bool containerMasksToBounds = !m_layoutView.frame()->isLocalRoot();
m_overflowControlsHostLayer->setMasksToBounds(containerMasksToBounds);
// Create a clipping layer if this is an iframe or settings require to clip.
m_containerLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
m_containerLayer->setMasksToBounds(containerMasksToBounds);
m_scrollLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
scrollingCoordinator->setLayerIsContainerForFixedPositionLayers(m_scrollLayer.get(), true);
// Hook them up
m_overflowControlsHostLayer->addChild(m_containerLayer.get());
m_containerLayer->addChild(m_scrollLayer.get());
m_scrollLayer->addChild(m_rootContentLayer.get());
frameViewDidChangeSize();
}
// Check to see if we have to change the attachment
if (m_rootLayerAttachment != RootLayerUnattached) {
detachRootLayer();
detachCompositorTimeline();
}
attachCompositorTimeline();
attachRootLayer(expectedAttachment);
}
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();
m_layerTreeContext.windowHandle = m_webPage->nativeWindowHandle();
GLContext* context = glContext();
if (!context) {
m_isValid = false;
return;
}
// The creation of the TextureMapper needs an active OpenGL context.
context->makeContextCurrent();
m_textureMapper = TextureMapperGL::create();
static_cast<TextureMapperGL*>(m_textureMapper.get())->setEnableEdgeDistanceAntialiasing(true);
toTextureMapperLayer(m_rootLayer.get())->setTextureMapper(m_textureMapper.get());
if (m_webPage->hasPageOverlay()) {
PageOverlayList& pageOverlays = m_webPage->pageOverlays();
PageOverlayList::iterator end = pageOverlays.end();
for (PageOverlayList::iterator it = pageOverlays.begin(); it != end; ++it)
createPageOverlayLayer(it->get());
}
scheduleLayerFlush();
}
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();
m_layerTreeContext.contextID = m_webPage->nativeWindowHandle();
GLContext* context = glContext();
if (!context)
return;
// The creation of the TextureMapper needs an active OpenGL context.
context->makeContextCurrent();
m_textureMapper = TextureMapper::create(TextureMapper::OpenGLMode);
static_cast<TextureMapperGL*>(m_textureMapper.get())->setEnableEdgeDistanceAntialiasing(true);
toTextureMapperLayer(m_rootLayer.get())->setTextureMapper(m_textureMapper.get());
// FIXME: Cretae page olverlay layers. https://bugs.webkit.org/show_bug.cgi?id=131433.
scheduleLayerFlush();
}
void CoordinatedLayerTreeHost::createPageOverlayLayer()
{
ASSERT(!m_pageOverlayLayer);
m_pageOverlayLayer = GraphicsLayer::create(graphicsLayerFactory(), m_coordinator.get());
#ifndef NDEBUG
m_pageOverlayLayer->setName("CompositingCoordinator page overlay content");
#endif
m_pageOverlayLayer->setDrawsContent(true);
m_pageOverlayLayer->setSize(m_coordinator->rootLayer()->size());
m_coordinator->rootLayer()->addChild(m_pageOverlayLayer.get());
}
void LayerTreeHostCA::createPageOverlayLayer()
{
ASSERT(!m_pageOverlayLayer);
m_pageOverlayLayer = GraphicsLayer::create(graphicsLayerFactory(), this);
#ifndef NDEBUG
m_pageOverlayLayer->setName("LayerTreeHost page overlay content");
#endif
m_pageOverlayLayer->setDrawsContent(true);
m_pageOverlayLayer->setSize(m_webPage->size());
m_rootLayer->addChild(m_pageOverlayLayer.get());
}
void LayerTreeHostGtk::createPageOverlayLayer(PageOverlay* pageOverlay)
{
std::unique_ptr<GraphicsLayer> layer = GraphicsLayer::create(graphicsLayerFactory(), this);
#ifndef NDEBUG
layer->setName("LayerTreeHost page overlay content");
#endif
layer->setAcceleratesDrawing(m_webPage->corePage()->settings().acceleratedDrawingEnabled());
layer->setDrawsContent(true);
layer->setSize(m_webPage->size());
layer->setShowDebugBorder(m_webPage->corePage()->settings().showDebugBorders());
layer->setShowRepaintCounter(m_webPage->corePage()->settings().showRepaintCounter());
m_rootLayer->addChild(layer.get());
m_pageOverlayLayers.add(pageOverlay, std::move(layer));
}
void PaintLayerCompositor::updateOverflowControlsLayers()
{
GraphicsLayer* controlsParent = m_overflowControlsHostLayer.get();
// Main frame scrollbars should always be stuck to the sides of the screen (in overscroll and in pinch-zoom), so
// make the parent for the scrollbars be the viewport container layer.
if (m_layoutView.frame()->isMainFrame()) {
VisualViewport& visualViewport = m_layoutView.frameView()->page()->frameHost().visualViewport();
controlsParent = visualViewport.containerLayer();
}
if (requiresHorizontalScrollbarLayer()) {
if (!m_layerForHorizontalScrollbar) {
m_layerForHorizontalScrollbar = GraphicsLayer::create(graphicsLayerFactory(), this);
}
if (m_layerForHorizontalScrollbar->parent() != controlsParent) {
controlsParent->addChild(m_layerForHorizontalScrollbar.get());
if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
scrollingCoordinator->scrollableAreaScrollbarLayerDidChange(m_layoutView.frameView(), HorizontalScrollbar);
}
} else if (m_layerForHorizontalScrollbar) {
m_layerForHorizontalScrollbar->removeFromParent();
m_layerForHorizontalScrollbar = nullptr;
if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
scrollingCoordinator->scrollableAreaScrollbarLayerDidChange(m_layoutView.frameView(), HorizontalScrollbar);
}
if (requiresVerticalScrollbarLayer()) {
if (!m_layerForVerticalScrollbar) {
m_layerForVerticalScrollbar = GraphicsLayer::create(graphicsLayerFactory(), this);
}
if (m_layerForVerticalScrollbar->parent() != controlsParent) {
controlsParent->addChild(m_layerForVerticalScrollbar.get());
if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
scrollingCoordinator->scrollableAreaScrollbarLayerDidChange(m_layoutView.frameView(), VerticalScrollbar);
}
} else if (m_layerForVerticalScrollbar) {
m_layerForVerticalScrollbar->removeFromParent();
m_layerForVerticalScrollbar = nullptr;
if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
scrollingCoordinator->scrollableAreaScrollbarLayerDidChange(m_layoutView.frameView(), VerticalScrollbar);
}
if (requiresScrollCornerLayer()) {
if (!m_layerForScrollCorner)
m_layerForScrollCorner = GraphicsLayer::create(graphicsLayerFactory(), this);
if (m_layerForScrollCorner->parent() != controlsParent)
controlsParent->addChild(m_layerForScrollCorner.get());
} else if (m_layerForScrollCorner) {
m_layerForScrollCorner->removeFromParent();
m_layerForScrollCorner = nullptr;
}
m_layoutView.frameView()->positionScrollbarLayers();
}