WebPageCompositor.cpp [plain text]
#include "config.h"
#include "WebPageCompositor.h"
#if USE(ACCELERATED_COMPOSITING)
#include "WebPageCompositorClient.h"
#include "WebPageCompositor_p.h"
#include "BackingStore_p.h"
#include "LayerWebKitThread.h"
#include "WebPage_p.h"
#include <BlackBerryPlatformDebugMacros.h>
#include <BlackBerryPlatformExecutableMessage.h>
#include <BlackBerryPlatformMessage.h>
#include <BlackBerryPlatformMessageClient.h>
#include <GenericTimerClient.h>
#include <ThreadTimerClient.h>
using namespace WebCore;
namespace BlackBerry {
namespace WebKit {
WebPageCompositorPrivate::WebPageCompositorPrivate(WebPagePrivate* page, WebPageCompositorClient* client)
: m_client(client)
, m_webPage(page)
, m_drawsRootLayer(false)
{
setOneShot(true); }
WebPageCompositorPrivate::~WebPageCompositorPrivate()
{
Platform::AnimationFrameRateController::instance()->removeClient(this);
}
void WebPageCompositorPrivate::setContext(Platform::Graphics::GLES2Context* context)
{
if (m_context == context)
return;
m_context = context;
if (!m_context) {
m_layerRenderer.clear();
return;
}
m_layerRenderer = LayerRenderer::create(m_context);
m_layerRenderer->setRootLayer(m_rootLayer.get());
}
bool WebPageCompositorPrivate::hardwareCompositing() const
{
return m_layerRenderer && m_layerRenderer->hardwareCompositing();
}
void WebPageCompositorPrivate::setRootLayer(LayerCompositingThread* rootLayer)
{
m_rootLayer = rootLayer;
if (m_layerRenderer)
m_layerRenderer->setRootLayer(m_rootLayer.get());
}
void WebPageCompositorPrivate::commit(LayerWebKitThread* rootLayer)
{
if (!rootLayer)
return;
rootLayer->commitOnCompositingThread();
}
void WebPageCompositorPrivate::render(const IntRect& dstRect, const IntRect& transformedContents)
{
if (m_webPage->compositor() != this)
return;
if (BackingStore* backingStore = m_webPage->m_backingStore)
backingStore->d->blitContents(dstRect, transformedContents, true);
else {
FloatRect contents = m_webPage->mapFromTransformedFloatRect(FloatRect(transformedContents));
drawLayers(dstRect, contents);
}
}
bool WebPageCompositorPrivate::drawsRootLayer() const
{
return m_drawsRootLayer;
}
bool WebPageCompositorPrivate::drawLayers(const IntRect& dstRect, const FloatRect& contents)
{
if (!m_layerRenderer)
return false;
bool shouldClear = drawsRootLayer();
if (BackingStore* backingStore = m_webPage->m_backingStore)
shouldClear = shouldClear || !backingStore->d->isOpenGLCompositing();
m_layerRenderer->setClearSurfaceOnDrawLayers(shouldClear);
m_layerRenderer->drawLayers(contents, m_layoutRectForCompositing, m_contentsSizeForCompositing, dstRect);
m_lastCompositingResults = m_layerRenderer->lastRenderingResults();
if (m_lastCompositingResults.needsAnimationFrame) {
Platform::AnimationFrameRateController::instance()->addClient(this);
m_webPage->updateDelegatedOverlays();
}
return true;
}
void WebPageCompositorPrivate::releaseLayerResources()
{
if (m_layerRenderer)
m_layerRenderer->releaseLayerResources();
}
void WebPageCompositorPrivate::animationFrameChanged()
{
BackingStore* backingStore = m_webPage->m_backingStore;
if (!backingStore) {
drawLayers(m_webPage->client()->userInterfaceBlittedDestinationRect(),
IntRect(m_webPage->client()->userInterfaceBlittedVisibleContentsRect()));
return;
}
if (backingStore->d->shouldDirectRenderingToWindow()) {
if (backingStore->d->isDirectRenderingAnimationMessageScheduled())
return;
using namespace BlackBerry::Platform;
backingStore->d->setDirectRenderingAnimationMessageScheduled();
webKitThreadMessageClient()->dispatchMessage(createMethodCallMessage(&BackingStorePrivate::renderVisibleContents, backingStore->d));
return;
}
m_webPage->blitVisibleContents();
}
void WebPageCompositorPrivate::compositorDestroyed()
{
if (m_client)
m_client->compositorDestroyed();
m_client = 0;
}
WebPageCompositor::WebPageCompositor(WebPage* page, WebPageCompositorClient* client)
{
using namespace BlackBerry::Platform;
RefPtr<WebPageCompositorPrivate> tmp = WebPageCompositorPrivate::create(page->d, client);
d = tmp.get();
d->ref();
webKitThreadMessageClient()->dispatchMessage(createMethodCallMessage(&WebPagePrivate::setCompositor, d->page(), tmp));
}
WebPageCompositor::~WebPageCompositor()
{
using namespace BlackBerry::Platform;
webKitThreadMessageClient()->dispatchMessage(createMethodCallMessage(&WebPagePrivate::setCompositor, d->page(), PassRefPtr<WebPageCompositorPrivate>(0)));
d->compositorDestroyed();
d->deref();
}
WebPageCompositorClient* WebPageCompositor::client() const
{
return 0;
}
void WebPageCompositor::prepareFrame(Platform::Graphics::GLES2Context* context, double timestamp)
{
d->setContext(context);
}
void WebPageCompositor::render(Platform::Graphics::GLES2Context* context, const Platform::IntRect& dstRect, const Platform::IntRect& contents)
{
d->setContext(context);
d->render(dstRect, contents);
}
void WebPageCompositor::cleanup(Platform::Graphics::GLES2Context* context)
{
d->setContext(0);
}
void WebPageCompositor::contextLost()
{
notImplemented();
}
} }
#else // USE(ACCELERATED_COMPOSITING)
namespace BlackBerry {
namespace WebKit {
WebPageCompositor::WebPageCompositor(WebPage*, WebPageCompositorClient*)
: d(0)
{
}
WebPageCompositor::~WebPageCompositor()
{
}
WebPageCompositorClient* WebPageCompositor::client() const
{
return 0;
}
void WebPageCompositor::prepareFrame(Platform::Graphics::GLES2Context*, double)
{
}
void WebPageCompositor::render(Platform::Graphics::GLES2Context*, const Platform::IntRect&, const Platform::IntRect&)
{
}
void WebPageCompositor::cleanup(Platform::Graphics::GLES2Context*)
{
}
void WebPageCompositor::contextLost()
{
}
} }
#endif // USE(ACCELERATED_COMPOSITING)