AcceleratedDrawingArea.cpp [plain text]
#include "config.h"
#include "AcceleratedDrawingArea.h"
#include "DrawingAreaProxyMessages.h"
#include "LayerTreeHost.h"
#include "UpdateInfo.h"
#include "WebPage.h"
#include "WebPageCreationParameters.h"
#include "WebPreferencesKeys.h"
#include <WebCore/MainFrame.h>
#include <WebCore/Page.h>
#include <WebCore/PageOverlayController.h>
#include <WebCore/Settings.h>
#if USE(GLIB_EVENT_LOOP)
#include <wtf/glib/RunLoopSourcePriority.h>
#endif
using namespace WebCore;
namespace WebKit {
AcceleratedDrawingArea::~AcceleratedDrawingArea()
{
discardPreviousLayerTreeHost();
if (m_layerTreeHost)
m_layerTreeHost->invalidate();
}
AcceleratedDrawingArea::AcceleratedDrawingArea(WebPage& webPage, const WebPageCreationParameters& parameters)
: DrawingArea(DrawingAreaTypeImpl, webPage)
, m_exitCompositingTimer(RunLoop::main(), this, &AcceleratedDrawingArea::exitAcceleratedCompositingMode)
, m_discardPreviousLayerTreeHostTimer(RunLoop::main(), this, &AcceleratedDrawingArea::discardPreviousLayerTreeHost)
{
#if USE(GLIB_EVENT_LOOP)
m_discardPreviousLayerTreeHostTimer.setPriority(RunLoopSourcePriority::ReleaseUnusedResourcesTimer);
#endif
if (!m_webPage.isVisible())
suspendPainting();
}
void AcceleratedDrawingArea::setNeedsDisplay()
{
if (!m_isPaintingEnabled)
return;
if (m_layerTreeHost)
m_layerTreeHost->setNonCompositedContentsNeedDisplay();
}
void AcceleratedDrawingArea::setNeedsDisplayInRect(const IntRect& rect)
{
if (!m_isPaintingEnabled)
return;
if (m_layerTreeHost)
m_layerTreeHost->setNonCompositedContentsNeedDisplayInRect(rect);
}
void AcceleratedDrawingArea::scroll(const IntRect& scrollRect, const IntSize& scrollDelta)
{
if (!m_isPaintingEnabled)
return;
if (m_layerTreeHost)
m_layerTreeHost->scrollNonCompositedContents(scrollRect);
}
void AcceleratedDrawingArea::pageBackgroundTransparencyChanged()
{
if (m_layerTreeHost)
m_layerTreeHost->pageBackgroundTransparencyChanged();
else if (m_previousLayerTreeHost)
m_previousLayerTreeHost->pageBackgroundTransparencyChanged();
}
void AcceleratedDrawingArea::setLayerTreeStateIsFrozen(bool isFrozen)
{
if (m_layerTreeStateIsFrozen == isFrozen)
return;
m_layerTreeStateIsFrozen = isFrozen;
if (m_layerTreeHost)
m_layerTreeHost->setLayerFlushSchedulingEnabled(!isFrozen);
if (isFrozen)
m_exitCompositingTimer.stop();
else if (m_wantsToExitAcceleratedCompositingMode)
exitAcceleratedCompositingModeSoon();
}
void AcceleratedDrawingArea::forceRepaint()
{
setNeedsDisplay();
m_webPage.layoutIfNeeded();
if (!m_layerTreeHost)
return;
if (m_compositingAccordingToProxyMessages)
m_layerTreeHost->forceRepaint();
else {
m_layerTreeHost->setShouldNotifyAfterNextScheduledLayerFlush(false);
layerHostDidFlushLayers();
}
}
bool AcceleratedDrawingArea::forceRepaintAsync(CallbackID callbackID)
{
return m_layerTreeHost && m_layerTreeHost->forceRepaintAsync(callbackID);
}
void AcceleratedDrawingArea::setPaintingEnabled(bool paintingEnabled)
{
m_isPaintingEnabled = paintingEnabled;
}
void AcceleratedDrawingArea::updatePreferences(const WebPreferencesStore& store)
{
m_webPage.corePage()->settings().setForceCompositingMode(store.getBoolValueForKey(WebPreferencesKey::forceCompositingModeKey()));
if (!m_layerTreeHost)
enterAcceleratedCompositingMode(nullptr);
}
void AcceleratedDrawingArea::mainFrameContentSizeChanged(const IntSize& size)
{
#if USE(COORDINATED_GRAPHICS_THREADED)
if (m_layerTreeHost)
m_layerTreeHost->contentsSizeChanged(size);
else if (m_previousLayerTreeHost)
m_previousLayerTreeHost->contentsSizeChanged(size);
#else
UNUSED_PARAM(size);
#endif
}
void AcceleratedDrawingArea::layerHostDidFlushLayers()
{
ASSERT(m_layerTreeHost);
m_layerTreeHost->forceRepaint();
if (m_shouldSendDidUpdateBackingStoreState && !exitAcceleratedCompositingModePending()) {
sendDidUpdateBackingStoreState();
return;
}
ASSERT(!m_compositingAccordingToProxyMessages);
if (!exitAcceleratedCompositingModePending()) {
m_webPage.send(Messages::DrawingAreaProxy::EnterAcceleratedCompositingMode(m_backingStoreStateID, m_layerTreeHost->layerTreeContext()));
m_compositingAccordingToProxyMessages = true;
}
}
GraphicsLayerFactory* AcceleratedDrawingArea::graphicsLayerFactory()
{
if (!m_layerTreeHost)
enterAcceleratedCompositingMode(nullptr);
return m_layerTreeHost ? m_layerTreeHost->graphicsLayerFactory() : nullptr;
}
void AcceleratedDrawingArea::setRootCompositingLayer(GraphicsLayer* graphicsLayer)
{
ASSERT(m_layerTreeHost);
if (graphicsLayer) {
m_exitCompositingTimer.stop();
m_wantsToExitAcceleratedCompositingMode = false;
if (!m_compositingAccordingToProxyMessages)
m_layerTreeHost->setShouldNotifyAfterNextScheduledLayerFlush(true);
}
m_layerTreeHost->setRootCompositingLayer(graphicsLayer);
}
void AcceleratedDrawingArea::scheduleCompositingLayerFlush()
{
if (m_layerTreeHost)
m_layerTreeHost->scheduleLayerFlush();
}
void AcceleratedDrawingArea::scheduleCompositingLayerFlushImmediately()
{
scheduleCompositingLayerFlush();
}
#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
RefPtr<WebCore::DisplayRefreshMonitor> AcceleratedDrawingArea::createDisplayRefreshMonitor(WebCore::PlatformDisplayID displayID)
{
if (!m_layerTreeHost || m_wantsToExitAcceleratedCompositingMode || exitAcceleratedCompositingModePending())
return nullptr;
return m_layerTreeHost->createDisplayRefreshMonitor(displayID);
}
#endif
void AcceleratedDrawingArea::updateBackingStoreState(uint64_t stateID, bool respondImmediately, float deviceScaleFactor, const IntSize& size, const IntSize& scrollOffset)
{
ASSERT(!m_inUpdateBackingStoreState);
m_inUpdateBackingStoreState = true;
ASSERT_ARG(stateID, stateID >= m_backingStoreStateID);
if (stateID != m_backingStoreStateID) {
m_backingStoreStateID = stateID;
m_shouldSendDidUpdateBackingStoreState = true;
m_webPage.setDeviceScaleFactor(deviceScaleFactor);
m_webPage.setSize(size);
m_webPage.layoutIfNeeded();
m_webPage.scrollMainFrameIfNotAtMaxScrollPosition(scrollOffset);
if (m_layerTreeHost)
m_layerTreeHost->sizeDidChange(m_webPage.size());
else if (m_previousLayerTreeHost)
m_previousLayerTreeHost->sizeDidChange(m_webPage.size());
} else {
ASSERT(size == m_webPage.size());
if (!m_shouldSendDidUpdateBackingStoreState) {
m_inUpdateBackingStoreState = false;
return;
}
}
didUpdateBackingStoreState();
if (respondImmediately) {
if (m_isPaintingSuspended)
resumePainting();
sendDidUpdateBackingStoreState();
}
m_inUpdateBackingStoreState = false;
}
void AcceleratedDrawingArea::sendDidUpdateBackingStoreState()
{
ASSERT(m_shouldSendDidUpdateBackingStoreState);
m_shouldSendDidUpdateBackingStoreState = false;
UpdateInfo updateInfo;
updateInfo.viewSize = m_webPage.size();
updateInfo.deviceScaleFactor = m_webPage.corePage()->deviceScaleFactor();
LayerTreeContext layerTreeContext;
if (m_layerTreeHost) {
layerTreeContext = m_layerTreeHost->layerTreeContext();
m_layerTreeHost->setShouldNotifyAfterNextScheduledLayerFlush(false);
m_layerTreeHost->forceRepaint();
}
m_webPage.send(Messages::DrawingAreaProxy::DidUpdateBackingStoreState(m_backingStoreStateID, updateInfo, layerTreeContext));
m_compositingAccordingToProxyMessages = !layerTreeContext.isEmpty();
}
void AcceleratedDrawingArea::suspendPainting()
{
ASSERT(!m_isPaintingSuspended);
if (m_layerTreeHost)
m_layerTreeHost->pauseRendering();
m_isPaintingSuspended = true;
m_webPage.corePage()->suspendScriptedAnimations();
}
void AcceleratedDrawingArea::resumePainting()
{
if (!m_isPaintingSuspended) {
return;
}
if (m_layerTreeHost)
m_layerTreeHost->resumeRendering();
m_isPaintingSuspended = false;
setNeedsDisplay();
m_webPage.corePage()->resumeScriptedAnimations();
}
void AcceleratedDrawingArea::enterAcceleratedCompositingMode(GraphicsLayer* graphicsLayer)
{
m_discardPreviousLayerTreeHostTimer.stop();
m_exitCompositingTimer.stop();
m_wantsToExitAcceleratedCompositingMode = false;
ASSERT(!m_layerTreeHost);
if (m_previousLayerTreeHost) {
#if USE(COORDINATED_GRAPHICS)
m_layerTreeHost = WTFMove(m_previousLayerTreeHost);
m_layerTreeHost->setIsDiscardable(false);
if (!m_isPaintingSuspended)
m_layerTreeHost->resumeRendering();
if (!m_layerTreeStateIsFrozen)
m_layerTreeHost->setLayerFlushSchedulingEnabled(true);
#else
ASSERT_NOT_REACHED();
#endif
} else {
m_layerTreeHost = LayerTreeHost::create(m_webPage);
if (m_isPaintingSuspended)
m_layerTreeHost->pauseRendering();
}
#if USE(TEXTURE_MAPPER_GL) && PLATFORM(GTK) && PLATFORM(X11) && !USE(REDIRECTED_XCOMPOSITE_WINDOW)
if (m_nativeSurfaceHandleForCompositing)
m_layerTreeHost->setNativeSurfaceHandleForCompositing(m_nativeSurfaceHandleForCompositing);
#endif
if (!m_inUpdateBackingStoreState)
m_layerTreeHost->setShouldNotifyAfterNextScheduledLayerFlush(true);
m_layerTreeHost->setRootCompositingLayer(graphicsLayer);
}
void AcceleratedDrawingArea::exitAcceleratedCompositingModeSoon()
{
if (m_layerTreeStateIsFrozen) {
m_wantsToExitAcceleratedCompositingMode = true;
return;
}
if (exitAcceleratedCompositingModePending())
return;
m_exitCompositingTimer.startOneShot(0_s);
}
#if USE(COORDINATED_GRAPHICS)
void AcceleratedDrawingArea::resetUpdateAtlasForTesting()
{
if (!m_layerTreeHost || exitAcceleratedCompositingModePending())
return;
m_layerTreeHost->clearUpdateAtlases();
}
#endif
void AcceleratedDrawingArea::exitAcceleratedCompositingModeNow()
{
ASSERT(!m_layerTreeStateIsFrozen);
m_exitCompositingTimer.stop();
m_wantsToExitAcceleratedCompositingMode = false;
#if USE(COORDINATED_GRAPHICS)
ASSERT(m_layerTreeHost);
m_previousLayerTreeHost = WTFMove(m_layerTreeHost);
m_previousLayerTreeHost->setIsDiscardable(true);
m_previousLayerTreeHost->pauseRendering();
m_previousLayerTreeHost->setLayerFlushSchedulingEnabled(false);
m_discardPreviousLayerTreeHostTimer.startOneShot(5_s);
#else
m_layerTreeHost = nullptr;
#endif
}
void AcceleratedDrawingArea::discardPreviousLayerTreeHost()
{
m_discardPreviousLayerTreeHostTimer.stop();
if (!m_previousLayerTreeHost)
return;
m_previousLayerTreeHost->invalidate();
m_previousLayerTreeHost = nullptr;
}
#if USE(TEXTURE_MAPPER_GL) && PLATFORM(GTK) && PLATFORM(X11) && !USE(REDIRECTED_XCOMPOSITE_WINDOW)
void AcceleratedDrawingArea::setNativeSurfaceHandleForCompositing(uint64_t handle)
{
m_nativeSurfaceHandleForCompositing = handle;
if (m_layerTreeHost) {
m_webPage.corePage()->settings().setAcceleratedCompositingEnabled(true);
m_layerTreeHost->setNativeSurfaceHandleForCompositing(handle);
}
}
void AcceleratedDrawingArea::destroyNativeSurfaceHandleForCompositing(bool& handled)
{
handled = true;
setNativeSurfaceHandleForCompositing(0);
}
#endif
#if USE(COORDINATED_GRAPHICS_THREADED)
void AcceleratedDrawingArea::didChangeViewportAttributes(ViewportAttributes&& attrs)
{
if (m_layerTreeHost)
m_layerTreeHost->didChangeViewportAttributes(WTFMove(attrs));
else if (m_previousLayerTreeHost)
m_previousLayerTreeHost->didChangeViewportAttributes(WTFMove(attrs));
}
#endif
#if USE(COORDINATED_GRAPHICS) || USE(TEXTURE_MAPPER)
void AcceleratedDrawingArea::deviceOrPageScaleFactorChanged()
{
if (m_layerTreeHost)
m_layerTreeHost->deviceOrPageScaleFactorChanged();
else if (m_previousLayerTreeHost)
m_previousLayerTreeHost->deviceOrPageScaleFactorChanged();
}
#endif
void AcceleratedDrawingArea::activityStateDidChange(ActivityState::Flags changed, bool, const Vector<CallbackID>&)
{
if (changed & ActivityState::IsVisible) {
if (m_webPage.isVisible())
resumePainting();
else
suspendPainting();
}
}
void AcceleratedDrawingArea::attachViewOverlayGraphicsLayer(Frame* frame, GraphicsLayer* viewOverlayRootLayer)
{
if (!frame->isMainFrame())
return;
if (m_layerTreeHost)
m_layerTreeHost->setViewOverlayRootLayer(viewOverlayRootLayer);
}
}