LayerCompositingThread.h [plain text]
#ifndef LayerCompositingThread_h
#define LayerCompositingThread_h
#if USE(ACCELERATED_COMPOSITING)
#include "FloatQuad.h"
#include "LayerData.h"
#include "LayerRendererSurface.h"
#include "LayerTiler.h"
#include <BlackBerryPlatformGuardedPointer.h>
#include <GuardedPointerDeleter.h>
namespace BlackBerry {
namespace Platform {
namespace Graphics {
class Buffer;
}
}
}
namespace WebCore {
class LayerRenderer;
class LayerCompositingThread : public ThreadSafeRefCounted<LayerCompositingThread>, public LayerData, public BlackBerry::Platform::GuardedPointerBase {
public:
static PassRefPtr<LayerCompositingThread> create(LayerType, PassRefPtr<LayerTiler>);
void setPluginView(PluginView*);
#if ENABLE(VIDEO)
void setMediaPlayer(MediaPlayer*);
#endif
void clearAnimations();
bool updateAnimations(double currentTime);
void updateTextureContentsIfNeeded();
void bindContentsTexture()
{
if (m_tiler)
m_tiler->bindContentsTexture();
}
const LayerCompositingThread* rootLayer() const;
void setSublayers(const Vector<RefPtr<LayerCompositingThread> >&);
const Vector<RefPtr<LayerCompositingThread> >& getSublayers() const { return m_sublayers; }
void setSuperlayer(LayerCompositingThread* superlayer) { m_superlayer = superlayer; }
LayerCompositingThread* superlayer() const { return m_superlayer; }
void setLayerRenderer(LayerRenderer*);
void setDrawTransform(const TransformationMatrix&);
const TransformationMatrix& drawTransform() const { return m_drawTransform; }
void setDrawOpacity(float opacity) { m_drawOpacity = opacity; }
float drawOpacity() const { return m_drawOpacity; }
void createLayerRendererSurface();
LayerRendererSurface* layerRendererSurface() const { return m_layerRendererSurface.get(); }
void clearLayerRendererSurface() { m_layerRendererSurface.clear(); }
void setMaskLayer(LayerCompositingThread* maskLayer) { m_maskLayer = maskLayer; }
LayerCompositingThread* maskLayer() const { return m_maskLayer.get(); }
void setReplicaLayer(LayerCompositingThread* layer) { m_replicaLayer = layer; }
LayerCompositingThread* replicaLayer() const { return m_replicaLayer.get(); }
FloatRect getDrawRect() const { return m_drawRect; }
const FloatQuad& getTransformedBounds() const { return m_transformedBounds; }
FloatQuad getTransformedHolePunchRect() const;
void deleteTextures();
void drawTextures(int positionLocation, int texCoordLocation, const FloatRect& visibleRect);
bool hasMissingTextures() const { return m_tiler ? m_tiler->hasMissingTextures() : false; }
void drawMissingTextures(int positionLocation, int texCoordLocation, const FloatRect& visibleRect);
void drawSurface(const TransformationMatrix&, LayerCompositingThread* mask, int positionLocation, int texCoordLocation);
bool isDirty() const { return m_tiler ? m_tiler->hasDirtyTiles() : false; }
void releaseTextureResources();
bool isVisible() const { return m_visible; }
void setVisible(bool);
void setNeedsCommit();
void scheduleCommit();
void setOpacity(float opacity) { m_opacity = opacity; }
void setTransform(const TransformationMatrix& matrix) { m_transform = matrix; }
bool hasRunningAnimations() const { return !m_runningAnimations.isEmpty(); }
bool hasVisibleHolePunchRect() const;
protected:
virtual ~LayerCompositingThread();
private:
LayerCompositingThread(LayerType, PassRefPtr<LayerTiler>);
void updateTileContents(const IntRect& tile);
void removeFromSuperlayer();
size_t numSublayers() const { return m_sublayers.size(); }
int indexOfSublayer(const LayerCompositingThread*);
void removeSublayer(LayerCompositingThread*);
LayerRenderer* m_layerRenderer;
typedef Vector<RefPtr<LayerCompositingThread> > LayerList;
LayerList m_sublayers;
LayerCompositingThread* m_superlayer;
FloatQuad m_transformedBounds;
FloatRect m_drawRect;
OwnPtr<LayerRendererSurface> m_layerRendererSurface;
RefPtr<LayerCompositingThread> m_maskLayer;
RefPtr<LayerCompositingThread> m_replicaLayer;
BlackBerry::Platform::Graphics::Buffer* m_pluginBuffer;
TransformationMatrix m_drawTransform;
float m_drawOpacity;
bool m_visible;
bool m_commitScheduled;
RefPtr<LayerTiler> m_tiler;
};
}
namespace WTF {
template<>
inline void ThreadSafeRefCounted<WebCore::LayerCompositingThread>::deref()
{
if (derefBase()) {
BlackBerry::Platform::GuardedPointerDeleter::deleteOnThread(
BlackBerry::Platform::userInterfaceThreadMessageClient(),
static_cast<WebCore::LayerCompositingThread*>(this));
}
}
}
#endif // USE(ACCELERATED_COMPOSITING)
#endif