DrawingAreaImpl.cpp [plain text]
#include "config.h"
#include "DrawingAreaImpl.h"
#include "DrawingAreaProxyMessages.h"
#include "LayerTreeContext.h"
#include "ShareableBitmap.h"
#include "UpdateInfo.h"
#include "WebPage.h"
#include "WebPageCreationParameters.h"
#include "WebPreferencesKeys.h"
#include "WebProcess.h"
#include <WebCore/GraphicsContext.h>
#include <WebCore/Page.h>
#include <WebCore/Settings.h>
using namespace WebCore;
namespace WebKit {
DrawingAreaImpl::~DrawingAreaImpl()
{
if (m_layerTreeHost)
m_layerTreeHost->invalidate();
}
DrawingAreaImpl::DrawingAreaImpl(WebPage& webPage, const WebPageCreationParameters& parameters)
: DrawingArea(DrawingAreaTypeImpl, webPage)
, m_backingStoreStateID(0)
, m_isPaintingEnabled(true)
, m_inUpdateBackingStoreState(false)
, m_shouldSendDidUpdateBackingStoreState(false)
, m_isWaitingForDidUpdate(false)
, m_compositingAccordingToProxyMessages(false)
, m_layerTreeStateIsFrozen(false)
, m_wantsToExitAcceleratedCompositingMode(false)
, m_isPaintingSuspended(!(parameters.viewState & ViewState::IsVisible))
, m_alwaysUseCompositing(false)
, m_displayTimer(RunLoop::main(), this, &DrawingAreaImpl::displayTimerFired)
, m_exitCompositingTimer(RunLoop::main(), this, &DrawingAreaImpl::exitAcceleratedCompositingMode)
{
if (webPage.corePage()->settings().acceleratedDrawingEnabled() || webPage.corePage()->settings().forceCompositingMode())
m_alwaysUseCompositing = true;
if (m_alwaysUseCompositing)
enterAcceleratedCompositingMode(0);
}
void DrawingAreaImpl::setNeedsDisplay()
{
if (!m_isPaintingEnabled)
return;
if (m_layerTreeHost) {
ASSERT(m_dirtyRegion.isEmpty());
m_layerTreeHost->setNonCompositedContentsNeedDisplay();
return;
}
setNeedsDisplayInRect(m_webPage.bounds());
}
void DrawingAreaImpl::setNeedsDisplayInRect(const IntRect& rect)
{
if (!m_isPaintingEnabled)
return;
if (m_layerTreeHost) {
ASSERT(m_dirtyRegion.isEmpty());
m_layerTreeHost->setNonCompositedContentsNeedDisplayInRect(rect);
return;
}
IntRect dirtyRect = rect;
dirtyRect.intersect(m_webPage.bounds());
if (dirtyRect.isEmpty())
return;
m_dirtyRegion.unite(dirtyRect);
scheduleDisplay();
}
void DrawingAreaImpl::scroll(const IntRect& scrollRect, const IntSize& scrollDelta)
{
if (!m_isPaintingEnabled)
return;
if (m_layerTreeHost) {
ASSERT(m_scrollRect.isEmpty());
ASSERT(m_scrollOffset.isEmpty());
ASSERT(m_dirtyRegion.isEmpty());
m_layerTreeHost->scrollNonCompositedContents(scrollRect);
return;
}
if (scrollRect.isEmpty())
return;
if (!m_scrollRect.isEmpty() && scrollRect != m_scrollRect) {
unsigned scrollArea = scrollRect.width() * scrollRect.height();
unsigned currentScrollArea = m_scrollRect.width() * m_scrollRect.height();
if (currentScrollArea >= scrollArea) {
setNeedsDisplayInRect(scrollRect);
return;
}
setNeedsDisplayInRect(m_scrollRect);
m_scrollRect = IntRect();
m_scrollOffset = IntSize();
}
Region dirtyRegionInScrollRect = intersect(scrollRect, m_dirtyRegion);
if (!dirtyRegionInScrollRect.isEmpty()) {
m_dirtyRegion.subtract(scrollRect);
Region movedDirtyRegionInScrollRect = intersect(translate(dirtyRegionInScrollRect, scrollDelta), scrollRect);
m_dirtyRegion.unite(movedDirtyRegionInScrollRect);
}
Region scrollRepaintRegion = subtract(scrollRect, translate(scrollRect, scrollDelta));
m_dirtyRegion.unite(scrollRepaintRegion);
scheduleDisplay();
m_scrollRect = scrollRect;
m_scrollOffset += scrollDelta;
}
void DrawingAreaImpl::pageBackgroundTransparencyChanged()
{
if (m_layerTreeHost)
m_layerTreeHost->pageBackgroundTransparencyChanged();
}
void DrawingAreaImpl::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 DrawingAreaImpl::forceRepaint()
{
setNeedsDisplay();
m_webPage.layoutIfNeeded();
if (m_layerTreeHost) {
if (m_compositingAccordingToProxyMessages)
m_layerTreeHost->forceRepaint();
else {
m_layerTreeHost->setShouldNotifyAfterNextScheduledLayerFlush(false);
layerHostDidFlushLayers();
}
return;
}
m_isWaitingForDidUpdate = false;
display();
}
bool DrawingAreaImpl::forceRepaintAsync(uint64_t callbackID)
{
return m_layerTreeHost && m_layerTreeHost->forceRepaintAsync(callbackID);
}
void DrawingAreaImpl::didInstallPageOverlay(PageOverlay* pageOverlay)
{
if (m_layerTreeHost)
m_layerTreeHost->didInstallPageOverlay(pageOverlay);
}
void DrawingAreaImpl::didUninstallPageOverlay(PageOverlay* pageOverlay)
{
if (m_layerTreeHost)
m_layerTreeHost->didUninstallPageOverlay(pageOverlay);
setNeedsDisplay();
}
void DrawingAreaImpl::setPageOverlayNeedsDisplay(PageOverlay* pageOverlay, const IntRect& rect)
{
if (m_layerTreeHost) {
m_layerTreeHost->setPageOverlayNeedsDisplay(pageOverlay, rect);
return;
}
setNeedsDisplayInRect(rect);
}
void DrawingAreaImpl::setPageOverlayOpacity(PageOverlay* pageOverlay, float value)
{
if (m_layerTreeHost)
m_layerTreeHost->setPageOverlayOpacity(pageOverlay, value);
}
void DrawingAreaImpl::setPaintingEnabled(bool paintingEnabled)
{
m_isPaintingEnabled = paintingEnabled;
}
void DrawingAreaImpl::updatePreferences(const WebPreferencesStore& store)
{
m_webPage.corePage()->settings().setForceCompositingMode(store.getBoolValueForKey(WebPreferencesKey::forceCompositingModeKey()));
}
void DrawingAreaImpl::layerHostDidFlushLayers()
{
ASSERT(m_layerTreeHost);
m_layerTreeHost->forceRepaint();
if (m_shouldSendDidUpdateBackingStoreState && !exitAcceleratedCompositingModePending()) {
sendDidUpdateBackingStoreState();
return;
}
if (!m_layerTreeHost)
return;
ASSERT(!m_compositingAccordingToProxyMessages);
if (!exitAcceleratedCompositingModePending()) {
m_webPage.send(Messages::DrawingAreaProxy::EnterAcceleratedCompositingMode(m_backingStoreStateID, m_layerTreeHost->layerTreeContext()));
m_compositingAccordingToProxyMessages = true;
}
}
GraphicsLayerFactory* DrawingAreaImpl::graphicsLayerFactory()
{
if (m_layerTreeHost)
return m_layerTreeHost->graphicsLayerFactory();
return 0;
}
void DrawingAreaImpl::setRootCompositingLayer(GraphicsLayer* graphicsLayer)
{
if (graphicsLayer) {
if (!m_layerTreeHost) {
enterAcceleratedCompositingMode(graphicsLayer);
} else {
m_exitCompositingTimer.stop();
m_wantsToExitAcceleratedCompositingMode = false;
if (!m_compositingAccordingToProxyMessages)
m_layerTreeHost->setShouldNotifyAfterNextScheduledLayerFlush(true);
m_layerTreeHost->setRootCompositingLayer(graphicsLayer);
}
} else {
if (m_layerTreeHost) {
m_layerTreeHost->setRootCompositingLayer(0);
if (!m_alwaysUseCompositing) {
if (m_inUpdateBackingStoreState)
exitAcceleratedCompositingMode();
else
exitAcceleratedCompositingModeSoon();
}
}
}
}
void DrawingAreaImpl::scheduleCompositingLayerFlush()
{
if (!m_layerTreeHost)
return;
m_layerTreeHost->scheduleLayerFlush();
}
void DrawingAreaImpl::scheduleCompositingLayerFlushImmediately()
{
scheduleCompositingLayerFlush();
}
void DrawingAreaImpl::updateBackingStoreState(uint64_t stateID, bool respondImmediately, float deviceScaleFactor, const WebCore::IntSize& size, const WebCore::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
m_dirtyRegion = m_webPage.bounds();
} else {
ASSERT(size == m_webPage.size());
if (!m_shouldSendDidUpdateBackingStoreState) {
m_inUpdateBackingStoreState = false;
return;
}
}
m_isWaitingForDidUpdate = false;
if (respondImmediately) {
if (m_isPaintingSuspended)
resumePainting();
sendDidUpdateBackingStoreState();
}
m_inUpdateBackingStoreState = false;
}
void DrawingAreaImpl::sendDidUpdateBackingStoreState()
{
ASSERT(!m_isWaitingForDidUpdate);
ASSERT(m_shouldSendDidUpdateBackingStoreState);
m_shouldSendDidUpdateBackingStoreState = false;
UpdateInfo updateInfo;
if (!m_isPaintingSuspended && !m_layerTreeHost)
display(updateInfo);
LayerTreeContext layerTreeContext;
if (m_isPaintingSuspended || m_layerTreeHost) {
updateInfo.viewSize = m_webPage.size();
updateInfo.deviceScaleFactor = m_webPage.corePage()->deviceScaleFactor();
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 DrawingAreaImpl::didUpdate()
{
if (m_layerTreeHost)
return;
m_isWaitingForDidUpdate = false;
displayTimerFired();
}
void DrawingAreaImpl::suspendPainting()
{
ASSERT(!m_isPaintingSuspended);
if (m_layerTreeHost)
m_layerTreeHost->pauseRendering();
m_isPaintingSuspended = true;
m_displayTimer.stop();
}
void DrawingAreaImpl::resumePainting()
{
if (!m_isPaintingSuspended) {
return;
}
if (m_layerTreeHost)
m_layerTreeHost->resumeRendering();
m_isPaintingSuspended = false;
setNeedsDisplay();
}
void DrawingAreaImpl::enterAcceleratedCompositingMode(GraphicsLayer* graphicsLayer)
{
m_exitCompositingTimer.stop();
m_wantsToExitAcceleratedCompositingMode = false;
ASSERT(!m_layerTreeHost);
m_layerTreeHost = LayerTreeHost::create(&m_webPage);
if (!m_inUpdateBackingStoreState)
m_layerTreeHost->setShouldNotifyAfterNextScheduledLayerFlush(true);
m_layerTreeHost->setRootCompositingLayer(graphicsLayer);
m_dirtyRegion = Region();
m_scrollRect = IntRect();
m_scrollOffset = IntSize();
m_displayTimer.stop();
m_isWaitingForDidUpdate = false;
}
void DrawingAreaImpl::exitAcceleratedCompositingMode()
{
if (m_alwaysUseCompositing)
return;
ASSERT(!m_layerTreeStateIsFrozen);
m_exitCompositingTimer.stop();
m_wantsToExitAcceleratedCompositingMode = false;
ASSERT(m_layerTreeHost);
m_layerTreeHost->invalidate();
m_layerTreeHost = nullptr;
m_dirtyRegion = m_webPage.bounds();
if (m_inUpdateBackingStoreState)
return;
if (m_shouldSendDidUpdateBackingStoreState) {
sendDidUpdateBackingStoreState();
return;
}
UpdateInfo updateInfo;
if (m_isPaintingSuspended) {
updateInfo.viewSize = m_webPage.size();
updateInfo.deviceScaleFactor = m_webPage.corePage()->deviceScaleFactor();
} else
display(updateInfo);
if (m_compositingAccordingToProxyMessages) {
m_webPage.send(Messages::DrawingAreaProxy::ExitAcceleratedCompositingMode(m_backingStoreStateID, updateInfo));
m_compositingAccordingToProxyMessages = false;
} else {
m_webPage.send(Messages::DrawingAreaProxy::Update(m_backingStoreStateID, updateInfo));
}
}
void DrawingAreaImpl::exitAcceleratedCompositingModeSoon()
{
if (m_layerTreeStateIsFrozen) {
m_wantsToExitAcceleratedCompositingMode = true;
return;
}
if (exitAcceleratedCompositingModePending())
return;
m_exitCompositingTimer.startOneShot(0);
}
void DrawingAreaImpl::scheduleDisplay()
{
ASSERT(!m_layerTreeHost);
if (m_isWaitingForDidUpdate)
return;
if (m_isPaintingSuspended)
return;
if (m_dirtyRegion.isEmpty())
return;
if (m_displayTimer.isActive())
return;
m_displayTimer.startOneShot(0);
}
void DrawingAreaImpl::displayTimerFired()
{
display();
}
void DrawingAreaImpl::display()
{
ASSERT(!m_layerTreeHost);
ASSERT(!m_isWaitingForDidUpdate);
ASSERT(!m_inUpdateBackingStoreState);
if (m_isPaintingSuspended)
return;
if (m_dirtyRegion.isEmpty())
return;
if (m_shouldSendDidUpdateBackingStoreState) {
sendDidUpdateBackingStoreState();
return;
}
UpdateInfo updateInfo;
display(updateInfo);
if (m_layerTreeHost) {
return;
}
m_webPage.send(Messages::DrawingAreaProxy::Update(m_backingStoreStateID, updateInfo));
m_isWaitingForDidUpdate = true;
}
static bool shouldPaintBoundsRect(const IntRect& bounds, const Vector<IntRect>& rects)
{
const size_t rectThreshold = 10;
const double wastedSpaceThreshold = 0.75;
if (rects.size() <= 1 || rects.size() > rectThreshold)
return true;
unsigned boundsArea = bounds.width() * bounds.height();
unsigned rectsArea = 0;
for (size_t i = 0; i < rects.size(); ++i)
rectsArea += rects[i].width() * rects[i].height();
double wastedSpace = 1 - (static_cast<double>(rectsArea) / boundsArea);
return wastedSpace <= wastedSpaceThreshold;
}
void DrawingAreaImpl::display(UpdateInfo& updateInfo)
{
ASSERT(!m_isPaintingSuspended);
ASSERT(!m_layerTreeHost);
ASSERT(!m_webPage.size().isEmpty());
m_webPage.layoutIfNeeded();
if (m_layerTreeHost)
return;
updateInfo.viewSize = m_webPage.size();
updateInfo.deviceScaleFactor = m_webPage.corePage()->deviceScaleFactor();
IntRect bounds = m_dirtyRegion.bounds();
ASSERT(m_webPage.bounds().contains(bounds));
IntSize bitmapSize = bounds.size();
float deviceScaleFactor = m_webPage.corePage()->deviceScaleFactor();
bitmapSize.scale(deviceScaleFactor);
RefPtr<ShareableBitmap> bitmap = ShareableBitmap::createShareable(bitmapSize, ShareableBitmap::SupportsAlpha);
if (!bitmap)
return;
if (!bitmap->createHandle(updateInfo.bitmapHandle))
return;
Vector<IntRect> rects = m_dirtyRegion.rects();
if (shouldPaintBoundsRect(bounds, rects)) {
rects.clear();
rects.append(bounds);
}
updateInfo.scrollRect = m_scrollRect;
updateInfo.scrollOffset = m_scrollOffset;
m_dirtyRegion = Region();
m_scrollRect = IntRect();
m_scrollOffset = IntSize();
auto graphicsContext = bitmap->createGraphicsContext();
graphicsContext->applyDeviceScaleFactor(deviceScaleFactor);
updateInfo.updateRectBounds = bounds;
graphicsContext->translate(-bounds.x(), -bounds.y());
for (size_t i = 0; i < rects.size(); ++i) {
m_webPage.drawRect(*graphicsContext, rects[i]);
updateInfo.updateRects.append(rects[i]);
}
m_displayTimer.stop();
}
}