RemoteLayerTreeDrawingArea.h [plain text]
#pragma once
#include "DrawingArea.h"
#include "GraphicsLayerCARemote.h"
#include "RemoteLayerTreeTransaction.h"
#include <WebCore/GraphicsLayerClient.h>
#include <WebCore/Timer.h>
#include <atomic>
#include <dispatch/dispatch.h>
#include <wtf/HashMap.h>
#include <wtf/WeakPtr.h>
namespace WebCore {
class PlatformCALayer;
}
namespace IPC {
class MessageEncoder;
}
namespace WebKit {
class RemoteLayerTreeContext;
class RemoteLayerTreeDisplayRefreshMonitor;
class RemoteLayerTreeDrawingArea : public DrawingArea, public WebCore::GraphicsLayerClient {
friend class RemoteLayerTreeDisplayRefreshMonitor;
public:
RemoteLayerTreeDrawingArea(WebPage&, const WebPageCreationParameters&);
virtual ~RemoteLayerTreeDrawingArea();
uint64_t nextTransactionID() const { return m_currentTransactionID + 1; }
WeakPtr<RemoteLayerTreeDrawingArea> createWeakPtr() { return m_weakPtrFactory.createWeakPtr(); }
private:
void setNeedsDisplay() override;
void setNeedsDisplayInRect(const WebCore::IntRect&) override;
void scroll(const WebCore::IntRect& scrollRect, const WebCore::IntSize& scrollDelta) override;
void updateGeometry(const WebCore::IntSize& viewSize, const WebCore::IntSize& layerPosition, bool flushSynchronously, const WebCore::MachSendRight& fencePort) override;
WebCore::GraphicsLayerFactory* graphicsLayerFactory() override;
void setRootCompositingLayer(WebCore::GraphicsLayer*) override;
void scheduleCompositingLayerFlush() override;
void scheduleCompositingLayerFlushImmediately() override;
void attachViewOverlayGraphicsLayer(WebCore::Frame*, WebCore::GraphicsLayer*) override;
void addTransactionCallbackID(uint64_t callbackID) override;
RefPtr<WebCore::DisplayRefreshMonitor> createDisplayRefreshMonitor(WebCore::PlatformDisplayID) override;
void willDestroyDisplayRefreshMonitor(WebCore::DisplayRefreshMonitor*);
bool shouldUseTiledBackingForFrameView(const WebCore::FrameView*) override;
void updatePreferences(const WebPreferencesStore&) override;
bool supportsAsyncScrolling() override { return true; }
void setLayerTreeStateIsFrozen(bool) override;
void forceRepaint() override;
bool forceRepaintAsync(uint64_t) override { return false; }
void setViewExposedRect(Optional<WebCore::FloatRect>) override;
Optional<WebCore::FloatRect> viewExposedRect() const override { return m_scrolledViewExposedRect; }
void acceleratedAnimationDidStart(uint64_t layerID, const String& key, double startTime) override;
void acceleratedAnimationDidEnd(uint64_t layerID, const String& key) override;
#if PLATFORM(IOS)
WebCore::FloatRect exposedContentRect() const override;
void setExposedContentRect(const WebCore::FloatRect&) override;
#endif
void didUpdate() override;
#if PLATFORM(IOS)
void setDeviceScaleFactor(float) override;
#endif
void mainFrameContentSizeChanged(const WebCore::IntSize&) override;
void viewStateDidChange(WebCore::ViewState::Flags changed, bool wantsDidUpdateViewState, const Vector<uint64_t>& callbackIDs) override;
bool adjustLayerFlushThrottling(WebCore::LayerFlushThrottleState::Flags) override;
bool dispatchDidLayout(WebCore::LayoutMilestones) override;
void updateScrolledExposedRect();
void updateRootLayers();
void flushLayers();
WebCore::TiledBacking* mainFrameTiledBacking() const;
uint64_t takeNextTransactionID() { return ++m_currentTransactionID; }
bool markLayersVolatileImmediatelyIfPossible() override;
class BackingStoreFlusher : public ThreadSafeRefCounted<BackingStoreFlusher> {
public:
static Ref<BackingStoreFlusher> create(IPC::Connection*, std::unique_ptr<IPC::MessageEncoder>, Vector<RetainPtr<CGContextRef>>);
void flush();
bool hasFlushed() const { return m_hasFlushed; }
private:
BackingStoreFlusher(IPC::Connection*, std::unique_ptr<IPC::MessageEncoder>, Vector<RetainPtr<CGContextRef>>);
RefPtr<IPC::Connection> m_connection;
std::unique_ptr<IPC::MessageEncoder> m_commitEncoder;
Vector<RetainPtr<CGContextRef>> m_contextsToFlush;
std::atomic<bool> m_hasFlushed;
};
std::unique_ptr<RemoteLayerTreeContext> m_remoteLayerTreeContext;
std::unique_ptr<WebCore::GraphicsLayer> m_rootLayer;
WebCore::IntSize m_viewSize;
Optional<WebCore::FloatRect> m_viewExposedRect;
Optional<WebCore::FloatRect> m_scrolledViewExposedRect;
WebCore::Timer m_layerFlushTimer;
bool m_isFlushingSuspended;
bool m_hasDeferredFlush;
bool m_isThrottlingLayerFlushes;
bool m_isLayerFlushThrottlingTemporarilyDisabledForInteraction;
bool m_isInitialThrottledLayerFlush;
bool m_waitingForBackingStoreSwap;
bool m_hadFlushDeferredWhileWaitingForBackingStoreSwap;
dispatch_queue_t m_commitQueue;
RefPtr<BackingStoreFlusher> m_pendingBackingStoreFlusher;
HashSet<RemoteLayerTreeDisplayRefreshMonitor*> m_displayRefreshMonitors;
HashSet<RemoteLayerTreeDisplayRefreshMonitor*>* m_displayRefreshMonitorsToNotify;
uint64_t m_currentTransactionID;
Vector<RemoteLayerTreeTransaction::TransactionCallbackID> m_pendingCallbackIDs;
WebCore::LayoutMilestones m_pendingNewlyReachedLayoutMilestones;
WebCore::GraphicsLayer* m_contentLayer;
WebCore::GraphicsLayer* m_viewOverlayRootLayer;
WeakPtrFactory<RemoteLayerTreeDrawingArea> m_weakPtrFactory;
};
}
SPECIALIZE_TYPE_TRAITS_DRAWING_AREA(RemoteLayerTreeDrawingArea, DrawingAreaTypeRemoteLayerTree)