зеркало из https://github.com/mozilla/gecko-dev.git
711 строки
20 KiB
C++
711 строки
20 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set sw=2 ts=2 et tw=80 : */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "CompositorParent.h"
|
|
#include "RenderTrace.h"
|
|
#include "ShadowLayersParent.h"
|
|
#include "BasicLayers.h"
|
|
#include "LayerManagerOGL.h"
|
|
#include "nsIWidget.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "RenderTrace.h"
|
|
|
|
#if defined(MOZ_WIDGET_ANDROID)
|
|
#include "AndroidBridge.h"
|
|
#include <android/log.h>
|
|
#endif
|
|
|
|
#include <map>
|
|
|
|
using base::Thread;
|
|
|
|
namespace mozilla {
|
|
namespace layers {
|
|
|
|
static Thread* sCompositorThread = nsnull;
|
|
|
|
/**
|
|
* Lookup the indirect shadow tree for |aId| and return it if it
|
|
* exists. Otherwise null is returned. This must only be called on
|
|
* the compositor thread.
|
|
*/
|
|
static Layer* GetIndirectShadowTree(uint64_t aId);
|
|
|
|
void CompositorParent::StartUp()
|
|
{
|
|
CreateCompositorMap();
|
|
CreateThread();
|
|
}
|
|
|
|
void CompositorParent::ShutDown()
|
|
{
|
|
DestroyThread();
|
|
DestroyCompositorMap();
|
|
}
|
|
|
|
bool CompositorParent::CreateThread()
|
|
{
|
|
NS_ASSERTION(NS_IsMainThread(), "Should be on the main Thread!");
|
|
if (sCompositorThread) {
|
|
return true;
|
|
}
|
|
sCompositorThread = new Thread("Compositor");
|
|
if (!sCompositorThread->Start()) {
|
|
delete sCompositorThread;
|
|
sCompositorThread = nsnull;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void CompositorParent::DestroyThread()
|
|
{
|
|
NS_ASSERTION(NS_IsMainThread(), "Should be on the main Thread!");
|
|
if (sCompositorThread) {
|
|
delete sCompositorThread;
|
|
sCompositorThread = nsnull;
|
|
}
|
|
}
|
|
|
|
MessageLoop* CompositorParent::CompositorLoop()
|
|
{
|
|
return sCompositorThread ? sCompositorThread->message_loop() : nsnull;
|
|
}
|
|
|
|
CompositorParent::CompositorParent(nsIWidget* aWidget,
|
|
bool aRenderToEGLSurface,
|
|
int aSurfaceWidth, int aSurfaceHeight)
|
|
: mWidget(aWidget)
|
|
, mCurrentCompositeTask(NULL)
|
|
, mPaused(false)
|
|
, mXScale(1.0)
|
|
, mYScale(1.0)
|
|
, mIsFirstPaint(false)
|
|
, mLayersUpdated(false)
|
|
, mRenderToEGLSurface(aRenderToEGLSurface)
|
|
, mEGLSurfaceSize(aSurfaceWidth, aSurfaceHeight)
|
|
, mPauseCompositionMonitor("PauseCompositionMonitor")
|
|
, mResumeCompositionMonitor("ResumeCompositionMonitor")
|
|
{
|
|
NS_ABORT_IF_FALSE(sCompositorThread != nsnull,
|
|
"The compositor thread must be Initialized before instanciating a COmpositorParent.");
|
|
MOZ_COUNT_CTOR(CompositorParent);
|
|
mCompositorID = 0;
|
|
// FIXME: This holds on the the fact that right now the only thing that
|
|
// can destroy this instance is initialized on the compositor thread after
|
|
// this task has been processed.
|
|
CompositorLoop()->PostTask(FROM_HERE, NewRunnableFunction(&AddCompositor,
|
|
this, &mCompositorID));
|
|
}
|
|
|
|
PlatformThreadId
|
|
CompositorParent::CompositorThreadID()
|
|
{
|
|
return sCompositorThread->thread_id();
|
|
}
|
|
|
|
CompositorParent::~CompositorParent()
|
|
{
|
|
MOZ_COUNT_DTOR(CompositorParent);
|
|
}
|
|
|
|
void
|
|
CompositorParent::Destroy()
|
|
{
|
|
NS_ABORT_IF_FALSE(ManagedPLayersParent().Length() == 0,
|
|
"CompositorParent destroyed before managed PLayersParent");
|
|
|
|
// Ensure that the layer manager is destructed on the compositor thread.
|
|
mLayerManager = NULL;
|
|
}
|
|
|
|
bool
|
|
CompositorParent::RecvWillStop()
|
|
{
|
|
mPaused = true;
|
|
RemoveCompositor(mCompositorID);
|
|
|
|
// Ensure that the layer manager is destroyed before CompositorChild.
|
|
mLayerManager->Destroy();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
CompositorParent::RecvStop()
|
|
{
|
|
Destroy();
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
CompositorParent::RecvPause()
|
|
{
|
|
PauseComposition();
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
CompositorParent::RecvResume()
|
|
{
|
|
ResumeComposition();
|
|
return true;
|
|
}
|
|
|
|
void
|
|
CompositorParent::ScheduleRenderOnCompositorThread()
|
|
{
|
|
CancelableTask *renderTask = NewRunnableMethod(this, &CompositorParent::ScheduleComposition);
|
|
CompositorLoop()->PostTask(FROM_HERE, renderTask);
|
|
}
|
|
|
|
void
|
|
CompositorParent::PauseComposition()
|
|
{
|
|
NS_ABORT_IF_FALSE(CompositorThreadID() == PlatformThread::CurrentId(),
|
|
"PauseComposition() can only be called on the compositor thread");
|
|
|
|
mozilla::MonitorAutoLock lock(mPauseCompositionMonitor);
|
|
|
|
if (!mPaused) {
|
|
mPaused = true;
|
|
|
|
#ifdef MOZ_WIDGET_ANDROID
|
|
static_cast<LayerManagerOGL*>(mLayerManager.get())->gl()->ReleaseSurface();
|
|
#endif
|
|
}
|
|
|
|
// if anyone's waiting to make sure that composition really got paused, tell them
|
|
lock.NotifyAll();
|
|
}
|
|
|
|
void
|
|
CompositorParent::ResumeComposition()
|
|
{
|
|
NS_ABORT_IF_FALSE(CompositorThreadID() == PlatformThread::CurrentId(),
|
|
"ResumeComposition() can only be called on the compositor thread");
|
|
|
|
mozilla::MonitorAutoLock lock(mResumeCompositionMonitor);
|
|
|
|
mPaused = false;
|
|
|
|
#ifdef MOZ_WIDGET_ANDROID
|
|
static_cast<LayerManagerOGL*>(mLayerManager.get())->gl()->RenewSurface();
|
|
#endif
|
|
|
|
Composite();
|
|
|
|
// if anyone's waiting to make sure that composition really got resumed, tell them
|
|
lock.NotifyAll();
|
|
}
|
|
|
|
void
|
|
CompositorParent::SetEGLSurfaceSize(int width, int height)
|
|
{
|
|
NS_ASSERTION(mRenderToEGLSurface, "Compositor created without RenderToEGLSurface ar provided");
|
|
mEGLSurfaceSize.SizeTo(width, height);
|
|
if (mLayerManager) {
|
|
static_cast<LayerManagerOGL*>(mLayerManager.get())->SetSurfaceSize(mEGLSurfaceSize.width, mEGLSurfaceSize.height);
|
|
}
|
|
}
|
|
|
|
void
|
|
CompositorParent::ResumeCompositionAndResize(int width, int height)
|
|
{
|
|
mWidgetSize.width = width;
|
|
mWidgetSize.height = height;
|
|
SetEGLSurfaceSize(width, height);
|
|
ResumeComposition();
|
|
}
|
|
|
|
/*
|
|
* This will execute a pause synchronously, waiting to make sure that the compositor
|
|
* really is paused.
|
|
*/
|
|
void
|
|
CompositorParent::SchedulePauseOnCompositorThread()
|
|
{
|
|
mozilla::MonitorAutoLock lock(mPauseCompositionMonitor);
|
|
|
|
CancelableTask *pauseTask = NewRunnableMethod(this,
|
|
&CompositorParent::PauseComposition);
|
|
CompositorLoop()->PostTask(FROM_HERE, pauseTask);
|
|
|
|
// Wait until the pause has actually been processed by the compositor thread
|
|
lock.Wait();
|
|
}
|
|
|
|
void
|
|
CompositorParent::ScheduleResumeOnCompositorThread(int width, int height)
|
|
{
|
|
mozilla::MonitorAutoLock lock(mResumeCompositionMonitor);
|
|
|
|
CancelableTask *resumeTask =
|
|
NewRunnableMethod(this, &CompositorParent::ResumeCompositionAndResize, width, height);
|
|
CompositorLoop()->PostTask(FROM_HERE, resumeTask);
|
|
|
|
// Wait until the resume has actually been processed by the compositor thread
|
|
lock.Wait();
|
|
}
|
|
|
|
void
|
|
CompositorParent::ScheduleTask(CancelableTask* task, int time)
|
|
{
|
|
if (time == 0) {
|
|
MessageLoop::current()->PostTask(FROM_HERE, task);
|
|
} else {
|
|
MessageLoop::current()->PostDelayedTask(FROM_HERE, task, time);
|
|
}
|
|
}
|
|
|
|
void
|
|
CompositorParent::ScheduleComposition()
|
|
{
|
|
if (mCurrentCompositeTask) {
|
|
return;
|
|
}
|
|
|
|
bool initialComposition = mLastCompose.IsNull();
|
|
TimeDuration delta;
|
|
if (!initialComposition)
|
|
delta = mozilla::TimeStamp::Now() - mLastCompose;
|
|
|
|
#ifdef COMPOSITOR_PERFORMANCE_WARNING
|
|
mExpectedComposeTime = mozilla::TimeStamp::Now() + TimeDuration::FromMilliseconds(15);
|
|
#endif
|
|
|
|
mCurrentCompositeTask = NewRunnableMethod(this, &CompositorParent::Composite);
|
|
|
|
// Since 60 fps is the maximum frame rate we can acheive, scheduling composition
|
|
// events less than 15 ms apart wastes computation..
|
|
if (!initialComposition && delta.ToMilliseconds() < 15) {
|
|
#ifdef COMPOSITOR_PERFORMANCE_WARNING
|
|
mExpectedComposeTime = mozilla::TimeStamp::Now() + TimeDuration::FromMilliseconds(15 - delta.ToMilliseconds());
|
|
#endif
|
|
ScheduleTask(mCurrentCompositeTask, 15 - delta.ToMilliseconds());
|
|
} else {
|
|
ScheduleTask(mCurrentCompositeTask, 0);
|
|
}
|
|
}
|
|
|
|
void
|
|
CompositorParent::SetTransformation(float aScale, nsIntPoint aScrollOffset)
|
|
{
|
|
mXScale = aScale;
|
|
mYScale = aScale;
|
|
mScrollOffset = aScrollOffset;
|
|
}
|
|
|
|
/**
|
|
* DRAWING PHASE ONLY
|
|
*
|
|
* For reach RefLayer in |aRoot|, look up its referent and connect it
|
|
* to the layer tree, if found. On exiting scope, detaches all
|
|
* resolved referents.
|
|
*/
|
|
class NS_STACK_CLASS AutoResolveRefLayers {
|
|
public:
|
|
/**
|
|
* |aRoot| must remain valid in the scope of this, which should be
|
|
* guaranteed by this helper only being used during the drawing
|
|
* phase.
|
|
*/
|
|
AutoResolveRefLayers(Layer* aRoot) : mRoot(aRoot)
|
|
{ WalkTheTree<Resolve>(mRoot, nsnull); }
|
|
|
|
~AutoResolveRefLayers()
|
|
{ WalkTheTree<Detach>(mRoot, nsnull); }
|
|
|
|
private:
|
|
enum Op { Resolve, Detach };
|
|
template<Op OP>
|
|
void WalkTheTree(Layer* aLayer, Layer* aParent)
|
|
{
|
|
if (RefLayer* ref = aLayer->AsRefLayer()) {
|
|
if (Layer* referent = GetIndirectShadowTree(ref->GetReferentId())) {
|
|
if (OP == Resolve) {
|
|
ref->ConnectReferentLayer(referent);
|
|
} else {
|
|
ref->DetachReferentLayer(referent);
|
|
}
|
|
}
|
|
}
|
|
for (Layer* child = aLayer->GetFirstChild();
|
|
child; child = child->GetNextSibling()) {
|
|
WalkTheTree<OP>(child, aLayer);
|
|
}
|
|
}
|
|
|
|
Layer* mRoot;
|
|
|
|
AutoResolveRefLayers(const AutoResolveRefLayers&) MOZ_DELETE;
|
|
AutoResolveRefLayers& operator=(const AutoResolveRefLayers&) MOZ_DELETE;
|
|
};
|
|
|
|
void
|
|
CompositorParent::Composite()
|
|
{
|
|
NS_ABORT_IF_FALSE(CompositorThreadID() == PlatformThread::CurrentId(),
|
|
"Composite can only be called on the compositor thread");
|
|
mCurrentCompositeTask = NULL;
|
|
|
|
mLastCompose = mozilla::TimeStamp::Now();
|
|
|
|
if (mPaused || !mLayerManager || !mLayerManager->GetRoot()) {
|
|
return;
|
|
}
|
|
|
|
Layer* aLayer = mLayerManager->GetRoot();
|
|
AutoResolveRefLayers resolve(aLayer);
|
|
|
|
TransformShadowTree();
|
|
|
|
mozilla::layers::RenderTraceLayers(aLayer, "0000");
|
|
|
|
mLayerManager->EndEmptyTransaction();
|
|
|
|
#ifdef COMPOSITOR_PERFORMANCE_WARNING
|
|
if (mExpectedComposeTime + TimeDuration::FromMilliseconds(15) < mozilla::TimeStamp::Now()) {
|
|
printf_stderr("Compositor: Composite took %i ms.\n",
|
|
15 + (int)(mozilla::TimeStamp::Now() - mExpectedComposeTime).ToMilliseconds());
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// Do a breadth-first search to find the first layer in the tree that is
|
|
// scrollable.
|
|
Layer*
|
|
CompositorParent::GetPrimaryScrollableLayer()
|
|
{
|
|
Layer* root = mLayerManager->GetRoot();
|
|
|
|
nsTArray<Layer*> queue;
|
|
queue.AppendElement(root);
|
|
while (queue.Length()) {
|
|
ContainerLayer* containerLayer = queue[0]->AsContainerLayer();
|
|
queue.RemoveElementAt(0);
|
|
if (!containerLayer) {
|
|
continue;
|
|
}
|
|
|
|
const FrameMetrics& frameMetrics = containerLayer->GetFrameMetrics();
|
|
if (frameMetrics.IsScrollable()) {
|
|
return containerLayer;
|
|
}
|
|
|
|
Layer* child = containerLayer->GetFirstChild();
|
|
while (child) {
|
|
queue.AppendElement(child);
|
|
child = child->GetNextSibling();
|
|
}
|
|
}
|
|
|
|
return root;
|
|
}
|
|
|
|
static void
|
|
Translate2D(gfx3DMatrix& aTransform, const gfxPoint& aOffset)
|
|
{
|
|
aTransform._41 += aOffset.x;
|
|
aTransform._42 += aOffset.y;
|
|
}
|
|
|
|
void
|
|
CompositorParent::TransformFixedLayers(Layer* aLayer,
|
|
const gfxPoint& aTranslation,
|
|
const gfxPoint& aScaleDiff)
|
|
{
|
|
if (aLayer->GetIsFixedPosition() &&
|
|
!aLayer->GetParent()->GetIsFixedPosition()) {
|
|
// When a scale has been applied to a layer, it focuses around (0,0).
|
|
// The anchor position is used here as a scale focus point (assuming that
|
|
// aScaleDiff has already been applied) to re-focus the scale.
|
|
const gfxPoint& anchor = aLayer->GetFixedPositionAnchor();
|
|
gfxPoint translation(aTranslation.x - (anchor.x - anchor.x / aScaleDiff.x),
|
|
aTranslation.y - (anchor.y - anchor.y / aScaleDiff.y));
|
|
|
|
gfx3DMatrix layerTransform = aLayer->GetTransform();
|
|
Translate2D(layerTransform, translation);
|
|
ShadowLayer* shadow = aLayer->AsShadowLayer();
|
|
shadow->SetShadowTransform(layerTransform);
|
|
|
|
const nsIntRect* clipRect = aLayer->GetClipRect();
|
|
if (clipRect) {
|
|
nsIntRect transformedClipRect(*clipRect);
|
|
transformedClipRect.MoveBy(translation.x, translation.y);
|
|
shadow->SetShadowClipRect(&transformedClipRect);
|
|
}
|
|
}
|
|
|
|
for (Layer* child = aLayer->GetFirstChild();
|
|
child; child = child->GetNextSibling()) {
|
|
TransformFixedLayers(child, aTranslation, aScaleDiff);
|
|
}
|
|
}
|
|
|
|
// Go down shadow layer tree, setting properties to match their non-shadow
|
|
// counterparts.
|
|
static void
|
|
SetShadowProperties(Layer* aLayer)
|
|
{
|
|
// FIXME: Bug 717688 -- Do these updates in ShadowLayersParent::RecvUpdate.
|
|
ShadowLayer* shadow = aLayer->AsShadowLayer();
|
|
shadow->SetShadowTransform(aLayer->GetTransform());
|
|
shadow->SetShadowVisibleRegion(aLayer->GetVisibleRegion());
|
|
shadow->SetShadowClipRect(aLayer->GetClipRect());
|
|
|
|
for (Layer* child = aLayer->GetFirstChild();
|
|
child; child = child->GetNextSibling()) {
|
|
SetShadowProperties(child);
|
|
}
|
|
}
|
|
|
|
void
|
|
CompositorParent::TransformShadowTree()
|
|
{
|
|
Layer* layer = GetPrimaryScrollableLayer();
|
|
ShadowLayer* shadow = layer->AsShadowLayer();
|
|
ContainerLayer* container = layer->AsContainerLayer();
|
|
|
|
const FrameMetrics& metrics = container->GetFrameMetrics();
|
|
const gfx3DMatrix& rootTransform = mLayerManager->GetRoot()->GetTransform();
|
|
const gfx3DMatrix& currentTransform = layer->GetTransform();
|
|
|
|
float rootScaleX = rootTransform.GetXScale();
|
|
float rootScaleY = rootTransform.GetYScale();
|
|
|
|
if (mIsFirstPaint) {
|
|
mContentRect = metrics.mContentRect;
|
|
SetFirstPaintViewport(metrics.mViewportScrollOffset,
|
|
1/rootScaleX,
|
|
mContentRect,
|
|
metrics.mCSSContentRect);
|
|
mIsFirstPaint = false;
|
|
} else if (!metrics.mContentRect.IsEqualEdges(mContentRect)) {
|
|
mContentRect = metrics.mContentRect;
|
|
SetPageRect(metrics.mCSSContentRect);
|
|
}
|
|
|
|
// We synchronise the viewport information with Java after sending the above
|
|
// notifications, so that Java can take these into account in its response.
|
|
// Calculate the absolute display port to send to Java
|
|
nsIntRect displayPort = metrics.mDisplayPort;
|
|
nsIntPoint scrollOffset = metrics.mViewportScrollOffset;
|
|
displayPort.x += scrollOffset.x;
|
|
displayPort.y += scrollOffset.y;
|
|
|
|
SyncViewportInfo(displayPort, 1/rootScaleX, mLayersUpdated,
|
|
mScrollOffset, mXScale, mYScale);
|
|
mLayersUpdated = false;
|
|
|
|
// Handle transformations for asynchronous panning and zooming. We determine the
|
|
// zoom used by Gecko from the transformation set on the root layer, and we
|
|
// determine the scroll offset used by Gecko from the frame metrics of the
|
|
// primary scrollable layer. We compare this to the desired zoom and scroll
|
|
// offset in the view transform we obtained from Java in order to compute the
|
|
// transformation we need to apply.
|
|
float tempScaleDiffX = rootScaleX * mXScale;
|
|
float tempScaleDiffY = rootScaleY * mYScale;
|
|
|
|
nsIntPoint metricsScrollOffset(0, 0);
|
|
if (metrics.IsScrollable())
|
|
metricsScrollOffset = metrics.mViewportScrollOffset;
|
|
|
|
nsIntPoint scrollCompensation(
|
|
(mScrollOffset.x / tempScaleDiffX - metricsScrollOffset.x) * mXScale,
|
|
(mScrollOffset.y / tempScaleDiffY - metricsScrollOffset.y) * mYScale);
|
|
ViewTransform treeTransform(-scrollCompensation, mXScale, mYScale);
|
|
shadow->SetShadowTransform(gfx3DMatrix(treeTransform) * currentTransform);
|
|
|
|
// Translate fixed position layers so that they stay in the correct position
|
|
// when mScrollOffset and metricsScrollOffset differ.
|
|
gfxPoint offset;
|
|
gfxPoint scaleDiff;
|
|
|
|
// If the contents can fit entirely within the widget area on a particular
|
|
// dimenson, we need to translate and scale so that the fixed layers remain
|
|
// within the page boundaries.
|
|
if (mContentRect.width * tempScaleDiffX < mWidgetSize.width) {
|
|
offset.x = -metricsScrollOffset.x;
|
|
scaleDiff.x = NS_MIN(1.0f, mWidgetSize.width / (float)mContentRect.width);
|
|
} else {
|
|
offset.x = clamped(mScrollOffset.x / tempScaleDiffX, (float)mContentRect.x,
|
|
mContentRect.XMost() - mWidgetSize.width / tempScaleDiffX) -
|
|
metricsScrollOffset.x;
|
|
scaleDiff.x = tempScaleDiffX;
|
|
}
|
|
|
|
if (mContentRect.height * tempScaleDiffY < mWidgetSize.height) {
|
|
offset.y = -metricsScrollOffset.y;
|
|
scaleDiff.y = NS_MIN(1.0f, mWidgetSize.height / (float)mContentRect.height);
|
|
} else {
|
|
offset.y = clamped(mScrollOffset.y / tempScaleDiffY, (float)mContentRect.y,
|
|
mContentRect.YMost() - mWidgetSize.height / tempScaleDiffY) -
|
|
metricsScrollOffset.y;
|
|
scaleDiff.y = tempScaleDiffY;
|
|
}
|
|
|
|
TransformFixedLayers(layer, offset, scaleDiff);
|
|
}
|
|
|
|
void
|
|
CompositorParent::SetFirstPaintViewport(const nsIntPoint& aOffset, float aZoom,
|
|
const nsIntRect& aPageRect, const gfx::Rect& aCssPageRect)
|
|
{
|
|
#ifdef MOZ_WIDGET_ANDROID
|
|
mozilla::AndroidBridge::Bridge()->SetFirstPaintViewport(aOffset, aZoom, aPageRect, aCssPageRect);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
CompositorParent::SetPageRect(const gfx::Rect& aCssPageRect)
|
|
{
|
|
#ifdef MOZ_WIDGET_ANDROID
|
|
mozilla::AndroidBridge::Bridge()->SetPageRect(aCssPageRect);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
CompositorParent::SyncViewportInfo(const nsIntRect& aDisplayPort,
|
|
float aDisplayResolution, bool aLayersUpdated,
|
|
nsIntPoint& aScrollOffset, float& aScaleX, float& aScaleY)
|
|
{
|
|
#ifdef MOZ_WIDGET_ANDROID
|
|
mozilla::AndroidBridge::Bridge()->SyncViewportInfo(aDisplayPort, aDisplayResolution, aLayersUpdated,
|
|
aScrollOffset, aScaleX, aScaleY);
|
|
#endif
|
|
}
|
|
|
|
void
|
|
CompositorParent::ShadowLayersUpdated(ShadowLayersParent* aLayerTree,
|
|
bool isFirstPaint)
|
|
{
|
|
mIsFirstPaint = mIsFirstPaint || isFirstPaint;
|
|
mLayersUpdated = true;
|
|
Layer* root = aLayerTree->GetRoot();
|
|
mLayerManager->SetRoot(root);
|
|
if (root) {
|
|
SetShadowProperties(root);
|
|
}
|
|
ScheduleComposition();
|
|
}
|
|
|
|
PLayersParent*
|
|
CompositorParent::AllocPLayers(const LayersBackend& aBackendType,
|
|
const uint64_t& aId,
|
|
int32_t* aMaxTextureSize)
|
|
{
|
|
MOZ_ASSERT(aId == 0);
|
|
|
|
// mWidget doesn't belong to the compositor thread, so it should be set to
|
|
// NULL before returning from this method, to avoid accessing it elsewhere.
|
|
nsIntRect rect;
|
|
mWidget->GetBounds(rect);
|
|
mWidgetSize.width = rect.width;
|
|
mWidgetSize.height = rect.height;
|
|
|
|
if (aBackendType == LayerManager::LAYERS_OPENGL) {
|
|
nsRefPtr<LayerManagerOGL> layerManager;
|
|
layerManager =
|
|
new LayerManagerOGL(mWidget, mEGLSurfaceSize.width, mEGLSurfaceSize.height, mRenderToEGLSurface);
|
|
mWidget = NULL;
|
|
mLayerManager = layerManager;
|
|
ShadowLayerManager* shadowManager = layerManager->AsShadowManager();
|
|
if (shadowManager) {
|
|
shadowManager->SetCompositorID(mCompositorID);
|
|
}
|
|
|
|
if (!layerManager->Initialize()) {
|
|
NS_ERROR("Failed to init OGL Layers");
|
|
return NULL;
|
|
}
|
|
|
|
ShadowLayerManager* slm = layerManager->AsShadowManager();
|
|
if (!slm) {
|
|
return NULL;
|
|
}
|
|
*aMaxTextureSize = layerManager->GetMaxTextureSize();
|
|
return new ShadowLayersParent(slm, this, 0);
|
|
} else if (aBackendType == LayerManager::LAYERS_BASIC) {
|
|
nsRefPtr<LayerManager> layerManager = new BasicShadowLayerManager(mWidget);
|
|
mWidget = NULL;
|
|
mLayerManager = layerManager;
|
|
ShadowLayerManager* slm = layerManager->AsShadowManager();
|
|
if (!slm) {
|
|
return NULL;
|
|
}
|
|
*aMaxTextureSize = layerManager->GetMaxTextureSize();
|
|
return new ShadowLayersParent(slm, this, 0);
|
|
} else {
|
|
NS_ERROR("Unsupported backend selected for Async Compositor");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
bool
|
|
CompositorParent::DeallocPLayers(PLayersParent* actor)
|
|
{
|
|
delete actor;
|
|
return true;
|
|
}
|
|
|
|
|
|
typedef std::map<PRUint64,CompositorParent*> CompositorMap;
|
|
static CompositorMap* sCompositorMap;
|
|
|
|
void CompositorParent::CreateCompositorMap()
|
|
{
|
|
if (sCompositorMap == nsnull) {
|
|
sCompositorMap = new CompositorMap;
|
|
}
|
|
}
|
|
|
|
void CompositorParent::DestroyCompositorMap()
|
|
{
|
|
if (sCompositorMap != nsnull) {
|
|
NS_ASSERTION(sCompositorMap->empty(),
|
|
"The Compositor map should be empty when destroyed>");
|
|
delete sCompositorMap;
|
|
sCompositorMap = nsnull;
|
|
}
|
|
}
|
|
|
|
CompositorParent* CompositorParent::GetCompositor(PRUint64 id)
|
|
{
|
|
CompositorMap::iterator it = sCompositorMap->find(id);
|
|
return it != sCompositorMap->end() ? it->second : nsnull;
|
|
}
|
|
|
|
void CompositorParent::AddCompositor(CompositorParent* compositor, PRUint64* outID)
|
|
{
|
|
static PRUint64 sNextID = 1;
|
|
|
|
++sNextID;
|
|
(*sCompositorMap)[sNextID] = compositor;
|
|
*outID = sNextID;
|
|
}
|
|
|
|
CompositorParent* CompositorParent::RemoveCompositor(PRUint64 id)
|
|
{
|
|
CompositorMap::iterator it = sCompositorMap->find(id);
|
|
if (it == sCompositorMap->end()) {
|
|
return nsnull;
|
|
}
|
|
sCompositorMap->erase(it);
|
|
return it->second;
|
|
}
|
|
|
|
static Layer*
|
|
GetIndirectShadowTree(uint64_t aId)
|
|
{
|
|
// IMPL in later patch
|
|
return nsnull;
|
|
}
|
|
|
|
} // namespace layers
|
|
} // namespace mozilla
|
|
|