ThreadedCompositor.h [plain text]
#pragma once
#if USE(COORDINATED_GRAPHICS_THREADED)
#include "CompositingRunLoop.h"
#include "CoordinatedGraphicsScene.h"
#include <WebCore/CoordinatedGraphicsState.h>
#include <WebCore/GLContext.h>
#include <WebCore/IntSize.h>
#include <WebCore/TextureMapper.h>
#include <wtf/Atomics.h>
#include <wtf/FastMalloc.h>
#include <wtf/Noncopyable.h>
#include <wtf/ThreadSafeRefCounted.h>
#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
#include <WebCore/DisplayRefreshMonitor.h>
#endif
namespace WebKit {
class CoordinatedGraphicsScene;
class CoordinatedGraphicsSceneClient;
class ThreadedDisplayRefreshMonitor;
class WebPage;
class ThreadedCompositor : public CoordinatedGraphicsSceneClient, public ThreadSafeRefCounted<ThreadedCompositor> {
WTF_MAKE_NONCOPYABLE(ThreadedCompositor);
WTF_MAKE_FAST_ALLOCATED;
public:
class Client {
public:
virtual void renderNextFrame() = 0;
virtual void commitScrollOffset(uint32_t layerID, const WebCore::IntSize& offset) = 0;
virtual uint64_t nativeSurfaceHandleForCompositing() = 0;
virtual void didDestroyGLContext() = 0;
virtual void willRenderFrame() = 0;
virtual void didRenderFrame() = 0;
};
enum class ShouldDoFrameSync { No, Yes };
static Ref<ThreadedCompositor> create(Client&, WebPage&, const WebCore::IntSize&, float scaleFactor, ShouldDoFrameSync = ShouldDoFrameSync::Yes, WebCore::TextureMapper::PaintFlags = 0);
virtual ~ThreadedCompositor();
void setNativeSurfaceHandleForCompositing(uint64_t);
void setScaleFactor(float);
void setScrollPosition(const WebCore::IntPoint&, float scale);
void setViewportSize(const WebCore::IntSize&, float scale);
void setDrawsBackground(bool);
void updateSceneState(const WebCore::CoordinatedGraphicsState&);
void releaseUpdateAtlases(const Vector<uint32_t>&);
void invalidate();
void forceRepaint();
#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
RefPtr<WebCore::DisplayRefreshMonitor> displayRefreshMonitor(WebCore::PlatformDisplayID);
void requestDisplayRefreshMonitorUpdate();
void handleDisplayRefreshMonitorUpdate(bool hasBeenRescheduled);
#endif
void frameComplete();
private:
ThreadedCompositor(Client&, WebPage&, const WebCore::IntSize&, float scaleFactor, ShouldDoFrameSync, WebCore::TextureMapper::PaintFlags);
void renderNextFrame() override;
void updateViewport() override;
void commitScrollOffset(uint32_t layerID, const WebCore::IntSize& offset) override;
void renderLayerTree();
void sceneUpdateFinished();
void createGLContext();
Client& m_client;
RefPtr<CoordinatedGraphicsScene> m_scene;
std::unique_ptr<WebCore::GLContext> m_context;
uint64_t m_nativeSurfaceHandle;
ShouldDoFrameSync m_doFrameSync;
WebCore::TextureMapper::PaintFlags m_paintFlags { 0 };
bool m_inForceRepaint { false };
std::unique_ptr<CompositingRunLoop> m_compositingRunLoop;
struct {
Lock lock;
WebCore::IntSize viewportSize;
WebCore::IntPoint scrollPosition;
float scaleFactor { 1 };
bool drawsBackground { true };
bool needsResize { false };
Vector<WebCore::CoordinatedGraphicsState> states;
Vector<uint32_t> atlasesToRemove;
bool clientRendersNextFrame { false };
bool coordinateUpdateCompletionWithClient { false };
} m_attributes;
#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
Ref<ThreadedDisplayRefreshMonitor> m_displayRefreshMonitor;
#endif
};
}
#endif // USE(COORDINATED_GRAPHICS_THREADED)