CCLayerTreeHostImpl.h [plain text]
#ifndef CCLayerTreeHostImpl_h
#define CCLayerTreeHostImpl_h
#include "Color.h"
#include "LayerRendererChromium.h"
#include "cc/CCAnimationEvents.h"
#include "cc/CCInputHandler.h"
#include "cc/CCLayerSorter.h"
#include "cc/CCLayerTreeHost.h"
#include "cc/CCLayerTreeHostCommon.h"
#include "cc/CCRenderPass.h"
#include <wtf/PassOwnPtr.h>
#include <wtf/RefPtr.h>
namespace WebCore {
class CCActiveGestureAnimation;
class CCCompletionEvent;
class CCDebugRectHistory;
class CCFontAtlas;
class CCFrameRateCounter;
class CCHeadsUpDisplay;
class CCPageScaleAnimation;
class CCLayerImpl;
class CCLayerTreeHostImplTimeSourceAdapter;
class LayerRendererChromium;
class TextureAllocator;
struct LayerRendererCapabilities;
class TransformationMatrix;
class CCLayerTreeHostImplClient {
public:
virtual void didLoseContextOnImplThread() = 0;
virtual void onSwapBuffersCompleteOnImplThread() = 0;
virtual void setNeedsRedrawOnImplThread() = 0;
virtual void setNeedsCommitOnImplThread() = 0;
virtual void postAnimationEventsToMainThreadOnImplThread(PassOwnPtr<CCAnimationEventsVector>, double wallClockTime) = 0;
virtual void postSetContentsMemoryAllocationLimitBytesToMainThreadOnImplThread(size_t) = 0;
};
class CCLayerTreeHostImpl : public CCInputHandlerClient, LayerRendererChromiumClient {
WTF_MAKE_NONCOPYABLE(CCLayerTreeHostImpl);
typedef Vector<CCLayerImpl*> CCLayerList;
public:
static PassOwnPtr<CCLayerTreeHostImpl> create(const CCSettings&, CCLayerTreeHostImplClient*);
virtual ~CCLayerTreeHostImpl();
virtual CCInputHandlerClient::ScrollStatus scrollBegin(const IntPoint&, CCInputHandlerClient::ScrollInputType);
virtual void scrollBy(const IntSize&);
virtual void scrollEnd();
virtual void pinchGestureBegin();
virtual void pinchGestureUpdate(float, const IntPoint&);
virtual void pinchGestureEnd();
virtual void startPageScaleAnimation(const IntSize& targetPosition, bool anchorPoint, float pageScale, double startTime, double duration);
virtual CCActiveGestureAnimation* activeGestureAnimation() { return m_activeGestureAnimation.get(); }
virtual void setActiveGestureAnimation(PassOwnPtr<CCActiveGestureAnimation>);
virtual void scheduleAnimation();
struct FrameData {
CCRenderPassList renderPasses;
CCLayerList renderSurfaceLayerList;
};
virtual void beginCommit();
virtual void commitComplete();
virtual void animate(double monotonicTime, double wallClockTime);
virtual bool prepareToDraw(FrameData&);
virtual void drawLayers(const FrameData&);
void didDrawAllLayers(const FrameData&);
virtual const IntSize& viewportSize() const OVERRIDE { return m_viewportSize; }
virtual const CCSettings& settings() const OVERRIDE { return m_settings; }
virtual void didLoseContext() OVERRIDE;
virtual void onSwapBuffersComplete() OVERRIDE;
virtual void setFullRootLayerDamage() OVERRIDE;
virtual void setContentsMemoryAllocationLimitBytes(size_t) OVERRIDE;
bool canDraw();
GraphicsContext3D* context();
String layerTreeAsText() const;
void setFontAtlas(PassOwnPtr<CCFontAtlas>);
void finishAllRendering();
int frameNumber() const { return m_frameNumber; }
bool initializeLayerRenderer(PassRefPtr<GraphicsContext3D>);
bool isContextLost();
LayerRendererChromium* layerRenderer() { return m_layerRenderer.get(); }
const LayerRendererCapabilities& layerRendererCapabilities() const;
TextureAllocator* contentsTextureAllocator() const;
bool swapBuffers();
void readback(void* pixels, const IntRect&);
void setRootLayer(PassOwnPtr<CCLayerImpl>);
PassOwnPtr<CCLayerImpl> releaseRootLayer() { return m_rootLayerImpl.release(); }
CCLayerImpl* rootLayer() { return m_rootLayerImpl.get(); }
CCLayerImpl* scrollLayer() const { return m_scrollLayerImpl; }
bool visible() const { return m_visible; }
void setVisible(bool);
int sourceFrameNumber() const { return m_sourceFrameNumber; }
void setSourceFrameNumber(int frameNumber) { m_sourceFrameNumber = frameNumber; }
void setViewportSize(const IntSize&);
void setPageScaleFactorAndLimits(float pageScale, float minPageScale, float maxPageScale);
float pageScale() const { return m_pageScale; }
PassOwnPtr<CCScrollAndScaleSet> processScrollDeltas();
void startPageScaleAnimation(const IntSize& tragetPosition, bool useAnchor, float scale, double durationSec);
const Color& backgroundColor() const { return m_backgroundColor; }
void setBackgroundColor(const Color& color) { m_backgroundColor = color; }
bool needsAnimateLayers() const { return m_needsAnimateLayers; }
void setNeedsAnimateLayers() { m_needsAnimateLayers = true; }
void setNeedsRedraw();
CCFrameRateCounter* fpsCounter() const { return m_fpsCounter.get(); }
CCDebugRectHistory* debugRectHistory() const { return m_debugRectHistory.get(); }
protected:
CCLayerTreeHostImpl(const CCSettings&, CCLayerTreeHostImplClient*);
void animatePageScale(double monotonicTime);
void animateGestures(double monotonicTime);
virtual void animateLayers(double monotonicTime, double wallClockTime);
CCLayerTreeHostImplClient* m_client;
int m_sourceFrameNumber;
int m_frameNumber;
private:
void computeDoubleTapZoomDeltas(CCScrollAndScaleSet* scrollInfo);
void computePinchZoomDeltas(CCScrollAndScaleSet* scrollInfo);
void makeScrollAndScaleSet(CCScrollAndScaleSet* scrollInfo, const IntSize& scrollOffset, float pageScale);
void setPageScaleDelta(float);
void applyPageScaleDeltaToScrollLayer();
void adjustScrollsForPageScaleChange(float);
void updateMaxScrollPosition();
void trackDamageForAllSurfaces(CCLayerImpl* rootDrawLayer, const CCLayerList& renderSurfaceLayerList);
void calculateRenderSurfaceLayerList(CCLayerList&);
bool calculateRenderPasses(CCRenderPassList&, CCLayerList& renderSurfaceLayerList);
void animateLayersRecursive(CCLayerImpl*, double monotonicTime, double wallClockTime, CCAnimationEventsVector*, bool& didAnimate, bool& needsAnimateLayers);
IntSize contentSize() const;
void sendDidLoseContextRecursive(CCLayerImpl*);
void clearRenderSurfacesOnCCLayerImplRecursive(CCLayerImpl*);
void dumpRenderSurfaces(TextStream&, int indent, const CCLayerImpl*) const;
OwnPtr<LayerRendererChromium> m_layerRenderer;
OwnPtr<CCLayerImpl> m_rootLayerImpl;
CCLayerImpl* m_scrollLayerImpl;
CCSettings m_settings;
IntSize m_viewportSize;
bool m_visible;
OwnPtr<CCHeadsUpDisplay> m_headsUpDisplay;
float m_pageScale;
float m_pageScaleDelta;
float m_sentPageScaleDelta;
float m_minPageScale, m_maxPageScale;
Color m_backgroundColor;
bool m_needsAnimateLayers;
bool m_pinchGestureActive;
IntPoint m_previousPinchAnchor;
OwnPtr<CCPageScaleAnimation> m_pageScaleAnimation;
OwnPtr<CCActiveGestureAnimation> m_activeGestureAnimation;
OwnPtr<CCLayerTreeHostImplTimeSourceAdapter> m_timeSourceClientAdapter;
CCLayerSorter m_layerSorter;
FloatRect m_rootDamageRect;
OwnPtr<CCFrameRateCounter> m_fpsCounter;
OwnPtr<CCDebugRectHistory> m_debugRectHistory;
};
};
#endif