CompositingCoordinator.h [plain text]
#ifndef CompositingCoordinator_h
#define CompositingCoordinator_h
#if USE(COORDINATED_GRAPHICS)
#include <WebCore/CoordinatedGraphicsLayer.h>
#include <WebCore/CoordinatedGraphicsState.h>
#include <WebCore/CoordinatedImageBacking.h>
#include <WebCore/FloatPoint.h>
#include <WebCore/GraphicsLayerClient.h>
#include <WebCore/GraphicsLayerFactory.h>
#include <WebCore/IntRect.h>
#include <WebCore/NicosiaBuffer.h>
namespace Nicosia {
class PaintingEngine;
}
namespace WebCore {
class GraphicsContext;
class GraphicsLayer;
class Page;
}
namespace WebKit {
class CompositingCoordinator final : public WebCore::GraphicsLayerClient
, public WebCore::CoordinatedGraphicsLayerClient
, public WebCore::CoordinatedImageBacking::Client
, public WebCore::GraphicsLayerFactory {
WTF_MAKE_NONCOPYABLE(CompositingCoordinator);
public:
class Client {
public:
virtual void didFlushRootLayer(const WebCore::FloatRect& visibleContentRect) = 0;
virtual void notifyFlushRequired() = 0;
virtual void commitSceneState(const WebCore::CoordinatedGraphicsState&) = 0;
};
CompositingCoordinator(WebCore::Page*, CompositingCoordinator::Client&);
virtual ~CompositingCoordinator();
void invalidate();
void setRootCompositingLayer(WebCore::GraphicsLayer*);
void setViewOverlayRootLayer(WebCore::GraphicsLayer*);
void sizeDidChange(const WebCore::IntSize&);
void deviceOrPageScaleFactorChanged();
void setVisibleContentsRect(const WebCore::FloatRect&);
void renderNextFrame();
void createRootLayer(const WebCore::IntSize&);
WebCore::GraphicsLayer* rootLayer() const { return m_rootLayer.get(); }
WebCore::GraphicsLayer* rootCompositingLayer() const { return m_rootCompositingLayer; }
void forceFrameSync() { m_shouldSyncFrame = true; }
bool flushPendingLayerChanges();
WebCore::CoordinatedGraphicsState& state() { return m_state; }
void syncDisplayState();
double nextAnimationServiceTime() const;
private:
void notifyFlushRequired(const WebCore::GraphicsLayer*) override;
float deviceScaleFactor() const override;
float pageScaleFactor() const override;
void createImageBacking(WebCore::CoordinatedImageBackingID) override;
void updateImageBacking(WebCore::CoordinatedImageBackingID, RefPtr<Nicosia::Buffer>&&) override;
void clearImageBackingContents(WebCore::CoordinatedImageBackingID) override;
void removeImageBacking(WebCore::CoordinatedImageBackingID) override;
bool isFlushingLayerChanges() const override { return m_isFlushingLayerChanges; }
WebCore::FloatRect visibleContentsRect() const override;
Ref<WebCore::CoordinatedImageBacking> createImageBackingIfNeeded(WebCore::Image&) override;
void detachLayer(WebCore::CoordinatedGraphicsLayer*) override;
void attachLayer(WebCore::CoordinatedGraphicsLayer*) override;
Nicosia::PaintingEngine& paintingEngine() override;
void syncLayerState(WebCore::CoordinatedLayerID, WebCore::CoordinatedGraphicsLayerState&) override;
std::unique_ptr<WebCore::GraphicsLayer> createGraphicsLayer(WebCore::GraphicsLayer::Type, WebCore::GraphicsLayerClient&) override;
void initializeRootCompositingLayerIfNeeded();
void flushPendingImageBackingChanges();
void clearPendingStateChanges();
void purgeBackingStores();
double timestamp() const;
WebCore::Page* m_page;
CompositingCoordinator::Client& m_client;
std::unique_ptr<WebCore::GraphicsLayer> m_rootLayer;
WebCore::GraphicsLayer* m_rootCompositingLayer { nullptr };
WebCore::GraphicsLayer* m_overlayCompositingLayer { nullptr };
WebCore::CoordinatedGraphicsState m_state;
HashMap<WebCore::CoordinatedLayerID, WebCore::CoordinatedGraphicsLayer*> m_registeredLayers;
HashMap<WebCore::CoordinatedImageBackingID, RefPtr<WebCore::CoordinatedImageBacking>> m_imageBackings;
std::unique_ptr<Nicosia::PaintingEngine> m_paintingEngine;
bool m_isDestructing { false };
bool m_isPurging { false };
bool m_isFlushingLayerChanges { false };
bool m_shouldSyncFrame { false };
bool m_didInitializeRootCompositingLayer { false };
WebCore::FloatRect m_visibleContentsRect;
double m_lastAnimationServiceTime { 0 };
};
}
#endif // namespace WebKit
#endif // CompositingCoordinator_h