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) {
// The call to update caused layout which turned on accelerated compositing.
// Don't send an Update message in this case.
return;
}
m_webPage->send(Messages::DrawingAreaProxy::Update(m_backingStoreStateID, updateInfo));
m_isWaitingForDidUpdate = true;
}
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) {
#if USE(COORDINATED_GRAPHICS)
// Coordinated Graphics sets the size of the root layer to contents size.
if (!m_webPage->useFixedLayout())
#endif
m_layerTreeHost->sizeDidChange(m_webPage->size());
} else
m_dirtyRegion = m_webPage->bounds();
} else {
ASSERT(size == m_webPage->size());
if (!m_shouldSendDidUpdateBackingStoreState) {
// We've already sent a DidUpdateBackingStoreState message for this state. We have nothing more to do.
m_inUpdateBackingStoreState = false;
return;
}
}
// The UI process has updated to a new backing store state. Any Update messages we sent before
// this point will be ignored. We wait to set this to false until after updating the page's
// size so that any displays triggered by the relayout will be ignored. If we're supposed to
// respond to the UpdateBackingStoreState message immediately, we'll do a display anyway in
// sendDidUpdateBackingStoreState; otherwise we shouldn't do one right now.
m_isWaitingForDidUpdate = false;
if (respondImmediately) {
// Make sure to resume painting if we're supposed to respond immediately, otherwise we'll just
// send back an empty UpdateInfo struct.
if (m_isPaintingSuspended)
resumePainting();
sendDidUpdateBackingStoreState();
}
m_inUpdateBackingStoreState = false;
}
void DrawingAreaImpl::exitAcceleratedCompositingMode()
{
if (m_alwaysUseCompositing && !m_webPage->mainFrameHasCustomRepresentation())
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 USE(ACCELERATED_COMPOSITING)
// Send along a complete update of the page so we can paint the contents right after we exit the
// accelerated compositing mode, eliminiating flicker.
if (m_compositingAccordingToProxyMessages) {
m_webPage->send(Messages::DrawingAreaProxy::ExitAcceleratedCompositingMode(m_backingStoreStateID, updateInfo));
m_compositingAccordingToProxyMessages = false;
} else {
// If we left accelerated compositing mode before we sent an EnterAcceleratedCompositingMode message to the
// UI process, we still need to let it know about the new contents, so send an Update message.
m_webPage->send(Messages::DrawingAreaProxy::Update(m_backingStoreStateID, updateInfo));
}
#endif
}
void CoordinatedDrawingArea::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;
}
}