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>
using namespace WebCore;
namespace WebKit {
AcceleratedDrawingArea::~AcceleratedDrawingArea()
{
if (m_layerTreeHost)
m_layerTreeHost->invalidate();
}
AcceleratedDrawingArea::AcceleratedDrawingArea(WebPage& webPage, const WebPageCreationParameters& parameters)
#if USE(COORDINATED_GRAPHICS_MULTIPROCESS)
: DrawingArea(DrawingAreaTypeCoordinated, webPage)
#else
: DrawingArea(DrawingAreaTypeImpl, webPage)
#endif
, m_exitCompositingTimer(RunLoop::main(), this, &AcceleratedDrawingArea::exitAcceleratedCompositingMode)
{
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();
}
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(uint64_t 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 (m_webPage.useFixedLayout() && m_layerTreeHost)
m_layerTreeHost->sizeDidChange(size);
m_webPage.mainFrame()->pageOverlayController().didChangeDocumentSize();
}
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()
{
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();
}
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 USE(COORDINATED_GRAPHICS_MULTIPROCESS)
if (!m_webPage.useFixedLayout())
m_layerTreeHost->sizeDidChange(m_webPage.size());
#else
if (m_layerTreeHost)
m_layerTreeHost->sizeDidChange(m_webPage.size());
#endif
} 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_exitCompositingTimer.stop();
m_wantsToExitAcceleratedCompositingMode = false;
ASSERT(!m_layerTreeHost);
m_layerTreeHost = LayerTreeHost::create(m_webPage);
#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);
if (m_isPaintingSuspended)
m_layerTreeHost->pauseRendering();
m_layerTreeHost->setRootCompositingLayer(graphicsLayer);
}
void AcceleratedDrawingArea::exitAcceleratedCompositingModeSoon()
{
if (m_layerTreeStateIsFrozen) {
m_wantsToExitAcceleratedCompositingMode = true;
return;
}
if (exitAcceleratedCompositingModePending())
return;
m_exitCompositingTimer.startOneShot(0);
}
#if USE(COORDINATED_GRAPHICS_MULTIPROCESS)
void AcceleratedDrawingArea::didReceiveCoordinatedLayerTreeHostMessage(IPC::Connection& connection, IPC::Decoder& decoder)
{
m_layerTreeHost->didReceiveCoordinatedLayerTreeHostMessage(connection, decoder);
}
#endif
#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
void AcceleratedDrawingArea::activityStateDidChange(ActivityState::Flags changed, bool, const Vector<uint64_t>&)
{
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);
}
}