LayerTreeHostGtk.cpp [plain text]
#include "config.h"
#include "LayerTreeHostGtk.h"
#if USE(TEXTURE_MAPPER_GL)
#include "DrawingAreaImpl.h"
#include "TextureMapperGL.h"
#include "WebPage.h"
#include "WebProcess.h"
#if USE(OPENGL_ES_2)
#include <GLES2/gl2.h>
#else
#include <GL/gl.h>
#endif
#include <WebCore/FrameView.h>
#include <WebCore/GLContext.h>
#include <WebCore/GraphicsLayerTextureMapper.h>
#include <WebCore/MainFrame.h>
#include <WebCore/Page.h>
#include <WebCore/Settings.h>
#include <wtf/CurrentTime.h>
#include <gdk/gdk.h>
#if defined(GDK_WINDOWING_X11)
#define Region XRegion
#define Font XFont
#define Cursor XCursor
#define Screen XScreen
#include <gdk/gdkx.h>
#endif
using namespace WebCore;
namespace WebKit {
PassRefPtr<LayerTreeHostGtk> LayerTreeHostGtk::create(WebPage* webPage)
{
RefPtr<LayerTreeHostGtk> host = adoptRef(new LayerTreeHostGtk(webPage));
host->initialize();
return host.release();
}
LayerTreeHostGtk::LayerTreeHostGtk(WebPage* webPage)
: LayerTreeHost(webPage)
, m_isValid(true)
, m_notifyAfterScheduledLayerFlush(false)
, m_lastFlushTime(0)
, m_layerFlushSchedulingEnabled(true)
{
}
GLContext* LayerTreeHostGtk::glContext()
{
if (m_context)
return m_context.get();
uint64_t windowHandle = m_webPage->nativeWindowHandle();
if (!windowHandle)
return 0;
m_context = GLContext::createContextForWindow(windowHandle, GLContext::sharingContext());
return m_context.get();
}
void LayerTreeHostGtk::initialize()
{
m_rootLayer = GraphicsLayer::create(graphicsLayerFactory(), *this);
m_rootLayer->setDrawsContent(false);
m_rootLayer->setSize(m_webPage->size());
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;
context->makeContextCurrent();
m_textureMapper = TextureMapper::create(TextureMapper::OpenGLMode);
static_cast<TextureMapperGL*>(m_textureMapper.get())->setEnableEdgeDistanceAntialiasing(true);
toTextureMapperLayer(m_rootLayer.get())->setTextureMapper(m_textureMapper.get());
scheduleLayerFlush();
}
LayerTreeHostGtk::~LayerTreeHostGtk()
{
ASSERT(!m_isValid);
ASSERT(!m_rootLayer);
cancelPendingLayerFlush();
}
const LayerTreeContext& LayerTreeHostGtk::layerTreeContext()
{
return m_layerTreeContext;
}
void LayerTreeHostGtk::setShouldNotifyAfterNextScheduledLayerFlush(bool notifyAfterScheduledLayerFlush)
{
m_notifyAfterScheduledLayerFlush = notifyAfterScheduledLayerFlush;
}
void LayerTreeHostGtk::setRootCompositingLayer(GraphicsLayer* graphicsLayer)
{
m_nonCompositedContentLayer->removeAllChildren();
if (graphicsLayer)
m_nonCompositedContentLayer->addChild(graphicsLayer);
scheduleLayerFlush();
}
void LayerTreeHostGtk::invalidate()
{
ASSERT(m_isValid);
if (m_context)
m_context->makeContextCurrent();
cancelPendingLayerFlush();
m_rootLayer = nullptr;
m_nonCompositedContentLayer = nullptr;
m_textureMapper = nullptr;
m_context = nullptr;
m_isValid = false;
}
void LayerTreeHostGtk::setNonCompositedContentsNeedDisplay()
{
m_nonCompositedContentLayer->setNeedsDisplay();
PageOverlayLayerMap::iterator end = m_pageOverlayLayers.end();
for (PageOverlayLayerMap::iterator it = m_pageOverlayLayers.begin(); it != end; ++it)
it->value->setNeedsDisplay();
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 LayerTreeHostGtk::scrollNonCompositedContents(const IntRect& scrollRect)
{
setNonCompositedContentsNeedDisplayInRect(scrollRect);
}
void LayerTreeHostGtk::sizeDidChange(const IntSize& newSize)
{
if (m_rootLayer->size() == newSize)
return;
m_rootLayer->setSize(newSize);
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->setNeedsDisplay();
PageOverlayLayerMap::iterator end = m_pageOverlayLayers.end();
for (PageOverlayLayerMap::iterator it = m_pageOverlayLayers.begin(); it != end; ++it)
it->value->setSize(newSize);
compositeLayersToContext(ForResize);
}
void LayerTreeHostGtk::deviceOrPageScaleFactorChanged()
{
m_nonCompositedContentLayer->deviceOrPageScaleFactorChanged();
}
void LayerTreeHostGtk::forceRepaint()
{
scheduleLayerFlush();
}
void LayerTreeHostGtk::didInstallPageOverlay(PageOverlay* pageOverlay)
{
createPageOverlayLayer(pageOverlay);
scheduleLayerFlush();
}
void LayerTreeHostGtk::didUninstallPageOverlay(PageOverlay* pageOverlay)
{
destroyPageOverlayLayer(pageOverlay);
scheduleLayerFlush();
}
void LayerTreeHostGtk::setPageOverlayNeedsDisplay(PageOverlay* pageOverlay, const IntRect& rect)
{
GraphicsLayer* layer = m_pageOverlayLayers.get(pageOverlay);
if (!layer)
return;
layer->setNeedsDisplayInRect(rect);
scheduleLayerFlush();
}
void LayerTreeHostGtk::notifyAnimationStarted(const WebCore::GraphicsLayer*, double )
{
}
void LayerTreeHostGtk::notifyFlushRequired(const WebCore::GraphicsLayer*)
{
}
void LayerTreeHostGtk::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& graphicsContext, GraphicsLayerPaintingPhase, const FloatRect& clipRect)
{
if (graphicsLayer == m_nonCompositedContentLayer.get()) {
m_webPage->drawRect(graphicsContext, enclosingIntRect(clipRect));
return;
}
}
void LayerTreeHostGtk::layerFlushTimerFired()
{
flushAndRenderLayers();
if (!m_layerFlushTimerCallback.isScheduled() && toTextureMapperLayer(m_rootLayer.get())->descendantsOrSelfHaveRunningAnimations()) {
const double targetFPS = 60;
double nextFlush = std::max((1 / targetFPS) - (currentTime() - m_lastFlushTime), 0.0);
m_layerFlushTimerCallback.scheduleAfterDelay("[WebKit] layerFlushTimer", std::bind(&LayerTreeHostGtk::layerFlushTimerFired, this),
std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::duration<double>(nextFlush)), GDK_PRIORITY_EVENTS);
}
}
bool LayerTreeHostGtk::flushPendingLayerChanges()
{
m_rootLayer->flushCompositingStateForThisLayerOnly();
m_nonCompositedContentLayer->flushCompositingStateForThisLayerOnly();
PageOverlayLayerMap::iterator end = m_pageOverlayLayers.end();
for (PageOverlayLayerMap::iterator it = m_pageOverlayLayers.begin(); it != end; ++it)
it->value->flushCompositingStateForThisLayerOnly();
return m_webPage->corePage()->mainFrame().view()->flushCompositingStateIncludingSubframes();
}
void LayerTreeHostGtk::compositeLayersToContext(CompositePurpose purpose)
{
GLContext* context = glContext();
if (!context || !context->makeContextCurrent())
return;
IntSize contextSize = m_context->defaultFrameBufferSize();
glViewport(0, 0, contextSize.width(), contextSize.height());
if (purpose == ForResize) {
glClearColor(1, 1, 1, 0);
glClear(GL_COLOR_BUFFER_BIT);
}
m_textureMapper->beginPainting();
toTextureMapperLayer(m_rootLayer.get())->paint();
m_textureMapper->endPainting();
context->swapBuffers();
}
void LayerTreeHostGtk::flushAndRenderLayers()
{
{
RefPtr<LayerTreeHostGtk> protect(this);
m_webPage->layoutIfNeeded();
if (!m_isValid)
return;
}
GLContext* context = glContext();
if (!context || !context->makeContextCurrent())
return;
m_lastFlushTime = currentTime();
if (!flushPendingLayerChanges())
return;
compositeLayersToContext();
if (m_notifyAfterScheduledLayerFlush) {
static_cast<DrawingAreaImpl*>(m_webPage->drawingArea())->layerHostDidFlushLayers();
m_notifyAfterScheduledLayerFlush = false;
}
}
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, WTF::move(layer));
}
void LayerTreeHostGtk::destroyPageOverlayLayer(PageOverlay* pageOverlay)
{
std::unique_ptr<GraphicsLayer> layer = m_pageOverlayLayers.take(pageOverlay);
ASSERT(layer);
layer->removeFromParent();
}
void LayerTreeHostGtk::scheduleLayerFlush()
{
if (!m_layerFlushSchedulingEnabled)
return;
if (!m_layerFlushTimerCallback.isScheduled())
m_layerFlushTimerCallback.schedule("[WebKit] layerFlushTimer", std::bind(&LayerTreeHostGtk::layerFlushTimerFired, this), GDK_PRIORITY_EVENTS);
}
void LayerTreeHostGtk::setLayerFlushSchedulingEnabled(bool layerFlushingEnabled)
{
if (m_layerFlushSchedulingEnabled == layerFlushingEnabled)
return;
m_layerFlushSchedulingEnabled = layerFlushingEnabled;
if (m_layerFlushSchedulingEnabled) {
scheduleLayerFlush();
return;
}
cancelPendingLayerFlush();
}
void LayerTreeHostGtk::pageBackgroundTransparencyChanged()
{
m_nonCompositedContentLayer->setContentsOpaque(m_webPage->drawsBackground() && !m_webPage->drawsTransparentBackground());
}
void LayerTreeHostGtk::cancelPendingLayerFlush()
{
m_layerFlushTimerCallback.cancel();
}
}
#endif