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_lastImmediateFlushTime(0)
, m_layerFlushSchedulingEnabled(true)
, m_viewOverlayRootLayer(nullptr)
{
}
bool LayerTreeHostGtk::makeContextCurrent()
{
if (!m_context) {
if (!m_layerTreeContext.contextID)
return false;
m_context = GLContext::createContextForWindow(reinterpret_cast<GLNativeWindowType>(m_layerTreeContext.contextID), GLContext::sharingContext());
if (!m_context)
return false;
}
return m_context->makeContextCurrent();
}
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();
}
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();
scheduleLayerFlush();
}
void LayerTreeHostGtk::setNonCompositedContentsNeedDisplayInRect(const IntRect& rect)
{
m_nonCompositedContentLayer->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();
compositeLayersToContext(ForResize);
}
void LayerTreeHostGtk::deviceOrPageScaleFactorChanged()
{
m_nonCompositedContentLayer->deviceOrPageScaleFactorChanged();
}
void LayerTreeHostGtk::forceRepaint()
{
scheduleLayerFlush();
}
void LayerTreeHostGtk::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& graphicsContext, GraphicsLayerPaintingPhase, const FloatRect& clipRect)
{
if (graphicsLayer == m_nonCompositedContentLayer.get())
m_webPage->drawRect(graphicsContext, enclosingIntRect(clipRect));
}
static inline bool shouldSkipNextFrameBecauseOfContinousImmediateFlushes(double current, double lastImmediateFlushTime)
{
static const double maxDurationOfImmediateFlushes = 0.100;
if (!lastImmediateFlushTime)
return false;
return lastImmediateFlushTime + maxDurationOfImmediateFlushes < current;
}
static const int layerFlushTimerPriority = GDK_PRIORITY_REDRAW - 1;
void LayerTreeHostGtk::layerFlushTimerFired()
{
double fireTime = monotonicallyIncreasingTime();
flushAndRenderLayers();
if (m_layerFlushTimerCallback.isScheduled() || !downcast<GraphicsLayerTextureMapper>(*m_rootLayer).layer().descendantsOrSelfHaveRunningAnimations())
return;
static const double targetFramerate = 1 / 60.0;
double current = monotonicallyIncreasingTime();
double timeToNextFlush = std::max(targetFramerate - (current - fireTime), 0.0);
if (timeToNextFlush)
m_lastImmediateFlushTime = 0;
else if (!m_lastImmediateFlushTime)
m_lastImmediateFlushTime = current;
if (shouldSkipNextFrameBecauseOfContinousImmediateFlushes(current, m_lastImmediateFlushTime)) {
timeToNextFlush = targetFramerate;
m_lastImmediateFlushTime = 0;
}
m_layerFlushTimerCallback.scheduleAfterDelay("[WebKit] layerFlushTimer", std::bind(&LayerTreeHostGtk::layerFlushTimerFired, this),
std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::duration<double>(timeToNextFlush)), layerFlushTimerPriority);
}
bool LayerTreeHostGtk::flushPendingLayerChanges()
{
bool viewportIsStable = m_webPage->corePage()->mainFrame().view()->viewportIsStable();
m_rootLayer->flushCompositingStateForThisLayerOnly(viewportIsStable);
m_nonCompositedContentLayer->flushCompositingStateForThisLayerOnly(viewportIsStable);
if (!m_webPage->corePage()->mainFrame().view()->flushCompositingStateIncludingSubframes())
return false;
if (m_viewOverlayRootLayer)
m_viewOverlayRootLayer->flushCompositingState(FloatRect(FloatPoint(), m_rootLayer->size()), viewportIsStable);
downcast<GraphicsLayerTextureMapper>(*m_rootLayer).updateBackingStoreIncludingSubLayers();
return true;
}
void LayerTreeHostGtk::compositeLayersToContext(CompositePurpose purpose)
{
if (!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);
}
ASSERT(m_textureMapper);
m_textureMapper->beginPainting();
downcast<GraphicsLayerTextureMapper>(*m_rootLayer).layer().paint();
m_textureMapper->endPainting();
m_context->swapBuffers();
}
void LayerTreeHostGtk::flushAndRenderLayers()
{
{
RefPtr<LayerTreeHostGtk> protect(this);
m_webPage->layoutIfNeeded();
if (!m_isValid)
return;
}
if (!makeContextCurrent())
return;
if (!flushPendingLayerChanges())
return;
compositeLayersToContext();
if (m_notifyAfterScheduledLayerFlush) {
static_cast<DrawingAreaImpl*>(m_webPage->drawingArea())->layerHostDidFlushLayers();
m_notifyAfterScheduledLayerFlush = false;
}
}
void LayerTreeHostGtk::scheduleLayerFlush()
{
if (!m_layerFlushSchedulingEnabled || !m_textureMapper)
return;
if (!m_layerFlushTimerCallback.isScheduled())
m_layerFlushTimerCallback.schedule("[WebKit] layerFlushTimer", std::bind(&LayerTreeHostGtk::layerFlushTimerFired, this), layerFlushTimerPriority);
}
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();
}
void LayerTreeHostGtk::setViewOverlayRootLayer(WebCore::GraphicsLayer* viewOverlayRootLayer)
{
m_viewOverlayRootLayer = viewOverlayRootLayer;
if (m_viewOverlayRootLayer)
m_rootLayer->addChild(m_viewOverlayRootLayer);
}
void LayerTreeHostGtk::setNativeSurfaceHandleForCompositing(uint64_t handle)
{
m_layerTreeContext.contextID = handle;
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();
}
}
#endif