ThreadedCompositor.h [plain text]
#ifndef ThreadedCompositor_h
#define ThreadedCompositor_h
#if USE(COORDINATED_GRAPHICS_THREADED)
#include "CoordinatedGraphicsScene.h"
#include "SimpleViewportController.h"
#include <WebCore/GLContext.h>
#include <WebCore/IntSize.h>
#include <WebCore/TransformationMatrix.h>
#include <wtf/FastMalloc.h>
#include <wtf/Noncopyable.h>
#include <wtf/ThreadSafeRefCounted.h>
#include <wtf/Threading.h>
namespace WebCore {
struct CoordinatedGraphicsState;
}
namespace WebKit {
class CoordinatedGraphicsScene;
class CoordinatedGraphicsSceneClient;
class CompositingRunLoop;
class ThreadedCompositor : public SimpleViewportController::Client, public CoordinatedGraphicsSceneClient, public ThreadSafeRefCounted<ThreadedCompositor> {
WTF_MAKE_NONCOPYABLE(ThreadedCompositor);
WTF_MAKE_FAST_ALLOCATED;
public:
class Client {
public:
virtual void setVisibleContentsRect(const WebCore::FloatRect&, const WebCore::FloatPoint&, float) = 0;
virtual void purgeBackingStores() = 0;
virtual void renderNextFrame() = 0;
virtual void commitScrollOffset(uint32_t layerID, const WebCore::IntSize& offset) = 0;
};
static Ref<ThreadedCompositor> create(Client*);
virtual ~ThreadedCompositor();
void setNeedsDisplay();
void setNativeSurfaceHandleForCompositing(uint64_t);
void updateSceneState(const WebCore::CoordinatedGraphicsState&);
void didChangeViewportSize(const WebCore::IntSize&);
void didChangeViewportAttribute(const WebCore::ViewportAttributes&);
void didChangeContentsSize(const WebCore::IntSize&);
void scrollTo(const WebCore::IntPoint&);
void scrollBy(const WebCore::IntSize&);
private:
ThreadedCompositor(Client*);
virtual void purgeBackingStores() override;
virtual void renderNextFrame() override;
virtual void updateViewport() override;
virtual void commitScrollOffset(uint32_t layerID, const WebCore::IntSize& offset) override;
void renderLayerTree();
void scheduleDisplayImmediately();
virtual void didChangeVisibleRect() override;
bool ensureGLContext();
WebCore::GLContext* glContext();
SimpleViewportController* viewportController() { return m_viewportController.get(); }
void callOnCompositingThread(std::function<void()>);
void createCompositingThread();
void runCompositingThread();
void terminateCompositingThread();
static void compositingThreadEntry(void*);
Client* m_client;
RefPtr<CoordinatedGraphicsScene> m_scene;
std::unique_ptr<SimpleViewportController> m_viewportController;
std::unique_ptr<WebCore::GLContext> m_context;
WebCore::IntSize m_viewportSize;
uint64_t m_nativeSurfaceHandle;
std::unique_ptr<CompositingRunLoop> m_compositingRunLoop;
ThreadIdentifier m_threadIdentifier;
ThreadCondition m_initializeRunLoopCondition;
Mutex m_initializeRunLoopConditionMutex;
ThreadCondition m_terminateRunLoopCondition;
Mutex m_terminateRunLoopConditionMutex;
};
}
#endif
#endif // ThreadedCompositor_h