mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
ffb19fb875
In order to make test behavior better match real-world sampling behavior, this patch updates the test code in CompositorParent so that it only updates the layer when a composite is scheduled. This enables creating mochitests that reproduce bugs observed in regular usage.
1279 lines
39 KiB
C++
1279 lines
39 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 <stdio.h> // for fprintf, stdout
|
|
#include <stdint.h> // for uint64_t
|
|
#include <map> // for _Rb_tree_iterator, etc
|
|
#include <utility> // for pair
|
|
#include "AutoOpenSurface.h" // for AutoOpenSurface
|
|
#include "LayerTransactionParent.h" // for LayerTransactionParent
|
|
#include "RenderTrace.h" // for RenderTraceLayers
|
|
#include "base/message_loop.h" // for MessageLoop
|
|
#include "base/process.h" // for ProcessHandle
|
|
#include "base/process_util.h" // for OpenProcessHandle
|
|
#include "base/task.h" // for CancelableTask, etc
|
|
#include "base/thread.h" // for Thread
|
|
#include "base/tracked.h" // for FROM_HERE
|
|
#include "gfxContext.h" // for gfxContext
|
|
#include "gfxPlatform.h" // for gfxPlatform
|
|
#include "gfxPrefs.h" // for gfxPrefs
|
|
#include "ipc/ShadowLayersManager.h" // for ShadowLayersManager
|
|
#include "mozilla/AutoRestore.h" // for AutoRestore
|
|
#include "mozilla/DebugOnly.h" // for DebugOnly
|
|
#include "mozilla/gfx/2D.h" // for DrawTarget
|
|
#include "mozilla/gfx/Point.h" // for IntSize
|
|
#include "mozilla/ipc/Transport.h" // for Transport
|
|
#include "mozilla/layers/APZCTreeManager.h" // for APZCTreeManager
|
|
#include "mozilla/layers/AsyncCompositionManager.h"
|
|
#include "mozilla/layers/BasicCompositor.h" // for BasicCompositor
|
|
#include "mozilla/layers/Compositor.h" // for Compositor
|
|
#include "mozilla/layers/CompositorOGL.h" // for CompositorOGL
|
|
#include "mozilla/layers/CompositorTypes.h"
|
|
#include "mozilla/layers/LayerManagerComposite.h"
|
|
#include "mozilla/layers/LayersTypes.h"
|
|
#include "mozilla/layers/PLayerTransactionParent.h"
|
|
#include "mozilla/mozalloc.h" // for operator new, etc
|
|
#include "nsCOMPtr.h" // for already_AddRefed
|
|
#include "nsDebug.h" // for NS_ABORT_IF_FALSE, etc
|
|
#include "nsISupportsImpl.h" // for MOZ_COUNT_CTOR, etc
|
|
#include "nsIWidget.h" // for nsIWidget
|
|
#include "nsRect.h" // for nsIntRect
|
|
#include "nsTArray.h" // for nsTArray
|
|
#include "nsThreadUtils.h" // for NS_IsMainThread
|
|
#include "nsXULAppAPI.h" // for XRE_GetIOMessageLoop
|
|
#ifdef XP_WIN
|
|
#include "mozilla/layers/CompositorD3D11.h"
|
|
#include "mozilla/layers/CompositorD3D9.h"
|
|
#endif
|
|
#include "GeckoProfiler.h"
|
|
#include "mozilla/ipc/ProtocolTypes.h"
|
|
|
|
using namespace base;
|
|
using namespace mozilla;
|
|
using namespace mozilla::ipc;
|
|
using namespace mozilla::gfx;
|
|
using namespace std;
|
|
|
|
namespace mozilla {
|
|
namespace layers {
|
|
|
|
CompositorParent::LayerTreeState::LayerTreeState()
|
|
: mParent(nullptr)
|
|
, mLayerManager(nullptr)
|
|
, mCrossProcessParent(nullptr)
|
|
{
|
|
}
|
|
|
|
typedef map<uint64_t, CompositorParent::LayerTreeState> LayerTreeMap;
|
|
static LayerTreeMap sIndirectLayerTrees;
|
|
|
|
// FIXME/bug 774386: we're assuming that there's only one
|
|
// CompositorParent, but that's not always true. This assumption only
|
|
// affects CrossProcessCompositorParent below.
|
|
static Thread* sCompositorThread = nullptr;
|
|
// manual reference count of the compositor thread.
|
|
static int sCompositorThreadRefCount = 0;
|
|
static MessageLoop* sMainLoop = nullptr;
|
|
// When ContentParent::StartUp() is called, we use the Thread global.
|
|
// When StartUpWithExistingThread() is used, we have to use the two
|
|
// duplicated globals, because there's no API to make a Thread from an
|
|
// existing thread.
|
|
static PlatformThreadId sCompositorThreadID = 0;
|
|
static MessageLoop* sCompositorLoop = nullptr;
|
|
|
|
static void DeferredDeleteCompositorParent(CompositorParent* aNowReadyToDie)
|
|
{
|
|
aNowReadyToDie->Release();
|
|
}
|
|
|
|
static void DeleteCompositorThread()
|
|
{
|
|
if (NS_IsMainThread()){
|
|
delete sCompositorThread;
|
|
sCompositorThread = nullptr;
|
|
sCompositorLoop = nullptr;
|
|
sCompositorThreadID = 0;
|
|
} else {
|
|
sMainLoop->PostTask(FROM_HERE, NewRunnableFunction(&DeleteCompositorThread));
|
|
}
|
|
}
|
|
|
|
static void ReleaseCompositorThread()
|
|
{
|
|
if(--sCompositorThreadRefCount == 0) {
|
|
DeleteCompositorThread();
|
|
}
|
|
}
|
|
|
|
void
|
|
CompositorParent::StartUpWithExistingThread(MessageLoop* aMsgLoop,
|
|
PlatformThreadId aThreadID)
|
|
{
|
|
MOZ_ASSERT(!sCompositorThread);
|
|
CreateCompositorMap();
|
|
sCompositorLoop = aMsgLoop;
|
|
sCompositorThreadID = aThreadID;
|
|
sMainLoop = MessageLoop::current();
|
|
sCompositorThreadRefCount = 1;
|
|
}
|
|
|
|
void CompositorParent::StartUp()
|
|
{
|
|
// Check if compositor started already with StartUpWithExistingThread
|
|
if (sCompositorThreadID) {
|
|
return;
|
|
}
|
|
MOZ_ASSERT(!sCompositorLoop);
|
|
CreateCompositorMap();
|
|
CreateThread();
|
|
sMainLoop = MessageLoop::current();
|
|
}
|
|
|
|
void CompositorParent::ShutDown()
|
|
{
|
|
DestroyThread();
|
|
DestroyCompositorMap();
|
|
}
|
|
|
|
bool CompositorParent::CreateThread()
|
|
{
|
|
NS_ASSERTION(NS_IsMainThread(), "Should be on the main Thread!");
|
|
if (sCompositorThread || sCompositorLoop) {
|
|
return true;
|
|
}
|
|
sCompositorThreadRefCount = 1;
|
|
sCompositorThread = new Thread("Compositor");
|
|
|
|
Thread::Options options;
|
|
/* Timeout values are powers-of-two to enable us get better data.
|
|
128ms is chosen for transient hangs because 8Hz should be the minimally
|
|
acceptable goal for Compositor responsiveness (normal goal is 60Hz). */
|
|
options.transient_hang_timeout = 128; // milliseconds
|
|
/* 8192ms is chosen for permanent hangs because it's several seconds longer
|
|
than the default hang timeout on major platforms (about 5 seconds). */
|
|
options.permanent_hang_timeout = 8192; // milliseconds
|
|
|
|
if (!sCompositorThread->StartWithOptions(options)) {
|
|
delete sCompositorThread;
|
|
sCompositorThread = nullptr;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void CompositorParent::DestroyThread()
|
|
{
|
|
NS_ASSERTION(NS_IsMainThread(), "Should be on the main Thread!");
|
|
ReleaseCompositorThread();
|
|
}
|
|
|
|
MessageLoop* CompositorParent::CompositorLoop()
|
|
{
|
|
return sCompositorThread ? sCompositorThread->message_loop() : sCompositorLoop;
|
|
}
|
|
|
|
CompositorParent::CompositorParent(nsIWidget* aWidget,
|
|
bool aUseExternalSurfaceSize,
|
|
int aSurfaceWidth, int aSurfaceHeight)
|
|
: mWidget(aWidget)
|
|
, mCurrentCompositeTask(nullptr)
|
|
, mIsTesting(false)
|
|
, mPaused(false)
|
|
, mUseExternalSurfaceSize(aUseExternalSurfaceSize)
|
|
, mEGLSurfaceSize(aSurfaceWidth, aSurfaceHeight)
|
|
, mPauseCompositionMonitor("PauseCompositionMonitor")
|
|
, mResumeCompositionMonitor("ResumeCompositionMonitor")
|
|
, mOverrideComposeReadiness(false)
|
|
, mForceCompositionTask(nullptr)
|
|
{
|
|
NS_ABORT_IF_FALSE(sCompositorThread != nullptr || sCompositorThreadID,
|
|
"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));
|
|
|
|
mRootLayerTreeID = AllocateLayerTreeId();
|
|
sIndirectLayerTrees[mRootLayerTreeID].mParent = this;
|
|
|
|
mApzcTreeManager = new APZCTreeManager();
|
|
++sCompositorThreadRefCount;
|
|
}
|
|
|
|
PlatformThreadId
|
|
CompositorParent::CompositorThreadID()
|
|
{
|
|
return sCompositorThread ? sCompositorThread->thread_id() : sCompositorThreadID;
|
|
}
|
|
|
|
bool
|
|
CompositorParent::IsInCompositorThread()
|
|
{
|
|
return CompositorThreadID() == PlatformThread::CurrentId();
|
|
}
|
|
|
|
uint64_t
|
|
CompositorParent::RootLayerTreeId()
|
|
{
|
|
return mRootLayerTreeID;
|
|
}
|
|
|
|
CompositorParent::~CompositorParent()
|
|
{
|
|
MOZ_COUNT_DTOR(CompositorParent);
|
|
|
|
ReleaseCompositorThread();
|
|
}
|
|
|
|
void
|
|
CompositorParent::Destroy()
|
|
{
|
|
NS_ABORT_IF_FALSE(ManagedPLayerTransactionParent().Length() == 0,
|
|
"CompositorParent destroyed before managed PLayerTransactionParent");
|
|
|
|
// Ensure that the layer manager is destructed on the compositor thread.
|
|
mLayerManager = nullptr;
|
|
mCompositor = nullptr;
|
|
mCompositionManager = nullptr;
|
|
mApzcTreeManager->ClearTree();
|
|
mApzcTreeManager = nullptr;
|
|
sIndirectLayerTrees.erase(mRootLayerTreeID);
|
|
}
|
|
|
|
void
|
|
CompositorParent::ForceIsFirstPaint()
|
|
{
|
|
mCompositionManager->ForceIsFirstPaint();
|
|
}
|
|
|
|
bool
|
|
CompositorParent::RecvWillStop()
|
|
{
|
|
mPaused = true;
|
|
RemoveCompositor(mCompositorID);
|
|
|
|
// Ensure that the layer manager is destroyed before CompositorChild.
|
|
if (mLayerManager) {
|
|
for (LayerTreeMap::iterator it = sIndirectLayerTrees.begin();
|
|
it != sIndirectLayerTrees.end(); it++)
|
|
{
|
|
LayerTreeState* lts = &it->second;
|
|
if (lts->mParent == this) {
|
|
mLayerManager->ClearCachedResources(lts->mRoot);
|
|
lts->mLayerManager = nullptr;
|
|
}
|
|
}
|
|
mLayerManager->Destroy();
|
|
mLayerManager = nullptr;
|
|
mCompositor = nullptr;
|
|
mCompositionManager = nullptr;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
CompositorParent::RecvStop()
|
|
{
|
|
Destroy();
|
|
// There are chances that the ref count reaches zero on the main thread shortly
|
|
// after this function returns while some ipdl code still needs to run on
|
|
// this thread.
|
|
// We must keep the compositor parent alive untill the code handling message
|
|
// reception is finished on this thread.
|
|
this->AddRef(); // Corresponds to DeferredDeleteCompositorParent's Release
|
|
CompositorLoop()->PostTask(FROM_HERE,
|
|
NewRunnableFunction(&DeferredDeleteCompositorParent,
|
|
this));
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
CompositorParent::RecvPause()
|
|
{
|
|
PauseComposition();
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
CompositorParent::RecvResume()
|
|
{
|
|
ResumeComposition();
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
CompositorParent::RecvMakeSnapshot(const SurfaceDescriptor& aInSnapshot,
|
|
SurfaceDescriptor* aOutSnapshot)
|
|
{
|
|
AutoOpenSurface opener(OPEN_READ_WRITE, aInSnapshot);
|
|
gfx::IntSize size = opener.Size();
|
|
// XXX CreateDrawTargetForSurface will always give us a Cairo surface, we can
|
|
// do better if AutoOpenSurface uses Moz2D directly.
|
|
RefPtr<DrawTarget> target =
|
|
gfxPlatform::GetPlatform()->CreateDrawTargetForSurface(opener.Get(), size);
|
|
ForceComposeToTarget(target);
|
|
*aOutSnapshot = aInSnapshot;
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
CompositorParent::RecvFlushRendering()
|
|
{
|
|
// If we're waiting to do a composite, then cancel it
|
|
// and do it immediately instead.
|
|
if (mCurrentCompositeTask) {
|
|
CancelCurrentCompositeTask();
|
|
ForceComposeToTarget(nullptr);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
CompositorParent::RecvNotifyRegionInvalidated(const nsIntRegion& aRegion)
|
|
{
|
|
if (mLayerManager) {
|
|
mLayerManager->AddInvalidRegion(aRegion);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
CompositorParent::RecvStartFrameTimeRecording(const int32_t& aBufferSize, uint32_t* aOutStartIndex)
|
|
{
|
|
if (mLayerManager) {
|
|
*aOutStartIndex = mLayerManager->StartFrameTimeRecording(aBufferSize);
|
|
} else {
|
|
*aOutStartIndex = 0;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
CompositorParent::RecvStopFrameTimeRecording(const uint32_t& aStartIndex,
|
|
InfallibleTArray<float>* intervals)
|
|
{
|
|
if (mLayerManager) {
|
|
mLayerManager->StopFrameTimeRecording(aStartIndex, *intervals);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
CompositorParent::RecvSetTestSampleTime(const TimeStamp& aTime)
|
|
{
|
|
if (aTime.IsNull()) {
|
|
return false;
|
|
}
|
|
|
|
mIsTesting = true;
|
|
mTestTime = aTime;
|
|
|
|
// Update but only if we were already scheduled to animate
|
|
if (mCompositionManager && mCurrentCompositeTask) {
|
|
bool requestNextFrame = mCompositionManager->TransformShadowTree(aTime);
|
|
if (!requestNextFrame) {
|
|
CancelCurrentCompositeTask();
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
CompositorParent::RecvLeaveTestMode()
|
|
{
|
|
mIsTesting = false;
|
|
return true;
|
|
}
|
|
|
|
void
|
|
CompositorParent::ActorDestroy(ActorDestroyReason why)
|
|
{
|
|
mPaused = true;
|
|
RemoveCompositor(mCompositorID);
|
|
|
|
if (mLayerManager) {
|
|
mLayerManager->Destroy();
|
|
mLayerManager = nullptr;
|
|
sIndirectLayerTrees[mRootLayerTreeID].mLayerManager = nullptr;
|
|
mCompositionManager = nullptr;
|
|
mCompositor = nullptr;
|
|
}
|
|
}
|
|
|
|
|
|
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");
|
|
|
|
MonitorAutoLock lock(mPauseCompositionMonitor);
|
|
|
|
if (!mPaused) {
|
|
mPaused = true;
|
|
|
|
mCompositor->Pause();
|
|
}
|
|
|
|
// 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");
|
|
|
|
MonitorAutoLock lock(mResumeCompositionMonitor);
|
|
|
|
if (!mCompositor->Resume()) {
|
|
#ifdef MOZ_WIDGET_ANDROID
|
|
// We can't get a surface. This could be because the activity changed between
|
|
// the time resume was scheduled and now.
|
|
__android_log_print(ANDROID_LOG_INFO, "CompositorParent", "Unable to renew compositor surface; remaining in paused state");
|
|
#endif
|
|
lock.NotifyAll();
|
|
return;
|
|
}
|
|
|
|
mPaused = false;
|
|
|
|
Composite();
|
|
|
|
// if anyone's waiting to make sure that composition really got resumed, tell them
|
|
lock.NotifyAll();
|
|
}
|
|
|
|
void
|
|
CompositorParent::ForceComposition()
|
|
{
|
|
// Cancel the orientation changed state to force composition
|
|
mForceCompositionTask = nullptr;
|
|
ScheduleRenderOnCompositorThread();
|
|
}
|
|
|
|
void
|
|
CompositorParent::CancelCurrentCompositeTask()
|
|
{
|
|
if (mCurrentCompositeTask) {
|
|
mCurrentCompositeTask->Cancel();
|
|
mCurrentCompositeTask = nullptr;
|
|
}
|
|
}
|
|
|
|
void
|
|
CompositorParent::SetEGLSurfaceSize(int width, int height)
|
|
{
|
|
NS_ASSERTION(mUseExternalSurfaceSize, "Compositor created without UseExternalSurfaceSize provided");
|
|
mEGLSurfaceSize.SizeTo(width, height);
|
|
if (mCompositor) {
|
|
mCompositor->SetDestinationSurfaceSize(gfx::IntSize(mEGLSurfaceSize.width, mEGLSurfaceSize.height));
|
|
}
|
|
}
|
|
|
|
void
|
|
CompositorParent::ResumeCompositionAndResize(int width, int height)
|
|
{
|
|
SetEGLSurfaceSize(width, height);
|
|
ResumeComposition();
|
|
}
|
|
|
|
/*
|
|
* This will execute a pause synchronously, waiting to make sure that the compositor
|
|
* really is paused.
|
|
*/
|
|
void
|
|
CompositorParent::SchedulePauseOnCompositorThread()
|
|
{
|
|
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();
|
|
}
|
|
|
|
bool
|
|
CompositorParent::ScheduleResumeOnCompositorThread(int width, int height)
|
|
{
|
|
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();
|
|
|
|
return !mPaused;
|
|
}
|
|
|
|
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::NotifyShadowTreeTransaction(uint64_t aId, bool aIsFirstPaint, bool aScheduleComposite)
|
|
{
|
|
if (mApzcTreeManager &&
|
|
mLayerManager &&
|
|
mLayerManager->GetRoot()) {
|
|
AutoResolveRefLayers resolve(mCompositionManager);
|
|
mApzcTreeManager->UpdatePanZoomControllerTree(this, mLayerManager->GetRoot(), aIsFirstPaint, aId);
|
|
|
|
mLayerManager->NotifyShadowTreeTransaction();
|
|
}
|
|
if (aScheduleComposite) {
|
|
ScheduleComposition();
|
|
}
|
|
}
|
|
|
|
// Used when layout.frame_rate is -1. Needs to be kept in sync with
|
|
// DEFAULT_FRAME_RATE in nsRefreshDriver.cpp.
|
|
static const int32_t kDefaultFrameRate = 60;
|
|
|
|
static int32_t
|
|
CalculateCompositionFrameRate()
|
|
{
|
|
int32_t compositionFrameRatePref = gfxPrefs::LayersCompositionFrameRate();
|
|
if (compositionFrameRatePref < 0) {
|
|
// Use the same frame rate for composition as for layout.
|
|
int32_t layoutFrameRatePref = gfxPrefs::LayoutFrameRate();
|
|
if (layoutFrameRatePref < 0) {
|
|
// TODO: The main thread frame scheduling code consults the actual
|
|
// monitor refresh rate in this case. We should do the same.
|
|
return kDefaultFrameRate;
|
|
}
|
|
return layoutFrameRatePref;
|
|
}
|
|
return compositionFrameRatePref;
|
|
}
|
|
|
|
void
|
|
CompositorParent::ScheduleComposition()
|
|
{
|
|
if (mCurrentCompositeTask || mPaused) {
|
|
return;
|
|
}
|
|
|
|
bool initialComposition = mLastCompose.IsNull();
|
|
TimeDuration delta;
|
|
if (!initialComposition)
|
|
delta = TimeStamp::Now() - mLastCompose;
|
|
|
|
int32_t rate = CalculateCompositionFrameRate();
|
|
|
|
// If rate == 0 (ASAP mode), minFrameDelta must be 0 so there's no delay.
|
|
TimeDuration minFrameDelta = TimeDuration::FromMilliseconds(
|
|
rate == 0 ? 0.0 : std::max(0.0, 1000.0 / rate));
|
|
|
|
|
|
mCurrentCompositeTask = NewRunnableMethod(this, &CompositorParent::Composite);
|
|
|
|
if (!initialComposition && delta < minFrameDelta) {
|
|
TimeDuration delay = minFrameDelta - delta;
|
|
#ifdef COMPOSITOR_PERFORMANCE_WARNING
|
|
mExpectedComposeStartTime = TimeStamp::Now() + delay;
|
|
#endif
|
|
ScheduleTask(mCurrentCompositeTask, delay.ToMilliseconds());
|
|
} else {
|
|
#ifdef COMPOSITOR_PERFORMANCE_WARNING
|
|
mExpectedComposeStartTime = TimeStamp::Now();
|
|
#endif
|
|
ScheduleTask(mCurrentCompositeTask, 0);
|
|
}
|
|
}
|
|
|
|
void
|
|
CompositorParent::Composite()
|
|
{
|
|
CompositeToTarget(nullptr);
|
|
}
|
|
|
|
void
|
|
CompositorParent::CompositeToTarget(DrawTarget* aTarget)
|
|
{
|
|
profiler_tracing("Paint", "Composite", TRACING_INTERVAL_START);
|
|
PROFILER_LABEL("CompositorParent", "Composite");
|
|
NS_ABORT_IF_FALSE(CompositorThreadID() == PlatformThread::CurrentId(),
|
|
"Composite can only be called on the compositor thread");
|
|
|
|
#ifdef COMPOSITOR_PERFORMANCE_WARNING
|
|
TimeDuration scheduleDelta = TimeStamp::Now() - mExpectedComposeStartTime;
|
|
if (scheduleDelta > TimeDuration::FromMilliseconds(2) ||
|
|
scheduleDelta < TimeDuration::FromMilliseconds(-2)) {
|
|
printf_stderr("Compositor: Compose starting off schedule by %4.1f ms\n",
|
|
scheduleDelta.ToMilliseconds());
|
|
}
|
|
#endif
|
|
|
|
mCurrentCompositeTask = nullptr;
|
|
|
|
mLastCompose = TimeStamp::Now();
|
|
|
|
if (!CanComposite()) {
|
|
return;
|
|
}
|
|
|
|
AutoResolveRefLayers resolve(mCompositionManager);
|
|
|
|
if (aTarget) {
|
|
mLayerManager->BeginTransactionWithDrawTarget(aTarget);
|
|
} else {
|
|
mLayerManager->BeginTransaction();
|
|
}
|
|
|
|
if (mForceCompositionTask && !mOverrideComposeReadiness) {
|
|
if (mCompositionManager->ReadyForCompose()) {
|
|
mForceCompositionTask->Cancel();
|
|
mForceCompositionTask = nullptr;
|
|
} else {
|
|
return;
|
|
}
|
|
}
|
|
|
|
TimeStamp time = mIsTesting ? mTestTime : mLastCompose;
|
|
bool requestNextFrame = mCompositionManager->TransformShadowTree(time);
|
|
if (requestNextFrame) {
|
|
ScheduleComposition();
|
|
}
|
|
|
|
RenderTraceLayers(mLayerManager->GetRoot(), "0000");
|
|
|
|
mCompositionManager->ComputeRotation();
|
|
|
|
#ifdef MOZ_DUMP_PAINTING
|
|
static bool gDumpCompositorTree = false;
|
|
if (gDumpCompositorTree) {
|
|
printf_stderr("Painting --- compositing layer tree:\n");
|
|
mLayerManager->Dump();
|
|
}
|
|
#endif
|
|
mLayerManager->SetDebugOverlayWantsNextFrame(false);
|
|
mLayerManager->EndEmptyTransaction();
|
|
|
|
if (mLayerManager->DebugOverlayWantsNextFrame()) {
|
|
ScheduleComposition();
|
|
}
|
|
|
|
#ifdef COMPOSITOR_PERFORMANCE_WARNING
|
|
TimeDuration executionTime = TimeStamp::Now() - mLastCompose;
|
|
TimeDuration frameBudget = TimeDuration::FromMilliseconds(15);
|
|
int32_t frameRate = CalculateCompositionFrameRate();
|
|
if (frameRate > 0) {
|
|
frameBudget = TimeDuration::FromSeconds(1.0 / frameRate);
|
|
}
|
|
if (executionTime > frameBudget) {
|
|
printf_stderr("Compositor: Composite execution took %4.1f ms\n",
|
|
executionTime.ToMilliseconds());
|
|
}
|
|
#endif
|
|
|
|
// 0 -> Full-tilt composite
|
|
if (gfxPrefs::LayersCompositionFrameRate() == 0) {
|
|
// Special full-tilt composite mode for performance testing
|
|
ScheduleComposition();
|
|
}
|
|
|
|
profiler_tracing("Paint", "Composite", TRACING_INTERVAL_END);
|
|
}
|
|
|
|
void
|
|
CompositorParent::ForceComposeToTarget(DrawTarget* aTarget)
|
|
{
|
|
PROFILER_LABEL("CompositorParent", "ForceComposeToTarget");
|
|
AutoRestore<bool> override(mOverrideComposeReadiness);
|
|
mOverrideComposeReadiness = true;
|
|
|
|
CompositeToTarget(aTarget);
|
|
}
|
|
|
|
bool
|
|
CompositorParent::CanComposite()
|
|
{
|
|
return !(mPaused || !mLayerManager || !mLayerManager->GetRoot());
|
|
}
|
|
|
|
// Go down the composite layer tree, setting properties to match their
|
|
// content-side counterparts.
|
|
static void
|
|
SetShadowProperties(Layer* aLayer)
|
|
{
|
|
// FIXME: Bug 717688 -- Do these updates in LayerTransactionParent::RecvUpdate.
|
|
LayerComposite* layerComposite = aLayer->AsLayerComposite();
|
|
// Set the layerComposite's base transform to the layer's base transform.
|
|
layerComposite->SetShadowTransform(aLayer->GetBaseTransform());
|
|
layerComposite->SetShadowTransformSetByAnimation(false);
|
|
layerComposite->SetShadowVisibleRegion(aLayer->GetVisibleRegion());
|
|
layerComposite->SetShadowClipRect(aLayer->GetClipRect());
|
|
layerComposite->SetShadowOpacity(aLayer->GetOpacity());
|
|
|
|
for (Layer* child = aLayer->GetFirstChild();
|
|
child; child = child->GetNextSibling()) {
|
|
SetShadowProperties(child);
|
|
}
|
|
}
|
|
|
|
void
|
|
CompositorParent::ShadowLayersUpdated(LayerTransactionParent* aLayerTree,
|
|
const TargetConfig& aTargetConfig,
|
|
bool aIsFirstPaint,
|
|
bool aScheduleComposite)
|
|
{
|
|
if (!aIsFirstPaint &&
|
|
!mCompositionManager->IsFirstPaint() &&
|
|
mCompositionManager->RequiresReorientation(aTargetConfig.orientation())) {
|
|
if (mForceCompositionTask != nullptr) {
|
|
mForceCompositionTask->Cancel();
|
|
}
|
|
mForceCompositionTask = NewRunnableMethod(this, &CompositorParent::ForceComposition);
|
|
ScheduleTask(mForceCompositionTask, gfxPrefs::OrientationSyncMillis());
|
|
}
|
|
|
|
// Instruct the LayerManager to update its render bounds now. Since all the orientation
|
|
// change, dimension change would be done at the stage, update the size here is free of
|
|
// race condition.
|
|
mLayerManager->UpdateRenderBounds(aTargetConfig.clientBounds());
|
|
|
|
mCompositionManager->Updated(aIsFirstPaint, aTargetConfig);
|
|
Layer* root = aLayerTree->GetRoot();
|
|
mLayerManager->SetRoot(root);
|
|
|
|
if (mApzcTreeManager) {
|
|
AutoResolveRefLayers resolve(mCompositionManager);
|
|
mApzcTreeManager->UpdatePanZoomControllerTree(this, root, aIsFirstPaint, mRootLayerTreeID);
|
|
}
|
|
|
|
if (root) {
|
|
SetShadowProperties(root);
|
|
}
|
|
if (aScheduleComposite) {
|
|
ScheduleComposition();
|
|
// When testing we synchronously update the shadow tree with the animated
|
|
// values to avoid race conditions when calling GetAnimationTransform etc.
|
|
// (since the above SetShadowProperties will remove animation effects).
|
|
// However, we only do this update when a composite operation is already
|
|
// scheduled in order to better match the behavior under regular sampling
|
|
// conditions.
|
|
if (mIsTesting && root && mCurrentCompositeTask) {
|
|
bool requestNextFrame =
|
|
mCompositionManager->TransformShadowTree(mTestTime);
|
|
if (!requestNextFrame) {
|
|
CancelCurrentCompositeTask();
|
|
}
|
|
}
|
|
}
|
|
mLayerManager->NotifyShadowTreeTransaction();
|
|
}
|
|
|
|
void
|
|
CompositorParent::ForceComposite(LayerTransactionParent* aLayerTree)
|
|
{
|
|
ScheduleComposition();
|
|
}
|
|
|
|
void
|
|
CompositorParent::InitializeLayerManager(const nsTArray<LayersBackend>& aBackendHints)
|
|
{
|
|
NS_ASSERTION(!mLayerManager, "Already initialised mLayerManager");
|
|
NS_ASSERTION(!mCompositor, "Already initialised mCompositor");
|
|
|
|
for (size_t i = 0; i < aBackendHints.Length(); ++i) {
|
|
RefPtr<Compositor> compositor;
|
|
if (aBackendHints[i] == LayersBackend::LAYERS_OPENGL) {
|
|
compositor = new CompositorOGL(mWidget,
|
|
mEGLSurfaceSize.width,
|
|
mEGLSurfaceSize.height,
|
|
mUseExternalSurfaceSize);
|
|
} else if (aBackendHints[i] == LayersBackend::LAYERS_BASIC) {
|
|
compositor = new BasicCompositor(mWidget);
|
|
#ifdef XP_WIN
|
|
} else if (aBackendHints[i] == LayersBackend::LAYERS_D3D11) {
|
|
compositor = new CompositorD3D11(mWidget);
|
|
} else if (aBackendHints[i] == LayersBackend::LAYERS_D3D9) {
|
|
compositor = new CompositorD3D9(this, mWidget);
|
|
#endif
|
|
}
|
|
|
|
if (!compositor) {
|
|
// We passed a backend hint for which we can't create a compositor.
|
|
// For example, we sometime pass LayersBackend::LAYERS_NONE as filler in aBackendHints.
|
|
continue;
|
|
}
|
|
|
|
compositor->SetCompositorID(mCompositorID);
|
|
RefPtr<LayerManagerComposite> layerManager = new LayerManagerComposite(compositor);
|
|
|
|
if (layerManager->Initialize()) {
|
|
mLayerManager = layerManager;
|
|
MOZ_ASSERT(compositor);
|
|
mCompositor = compositor;
|
|
sIndirectLayerTrees[mRootLayerTreeID].mLayerManager = layerManager;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
PLayerTransactionParent*
|
|
CompositorParent::AllocPLayerTransactionParent(const nsTArray<LayersBackend>& aBackendHints,
|
|
const uint64_t& aId,
|
|
TextureFactoryIdentifier* aTextureFactoryIdentifier,
|
|
bool *aSuccess)
|
|
{
|
|
MOZ_ASSERT(aId == 0);
|
|
|
|
// mWidget doesn't belong to the compositor thread, so it should be set to
|
|
// nullptr before returning from this method, to avoid accessing it elsewhere.
|
|
nsIntRect rect;
|
|
mWidget->GetClientBounds(rect);
|
|
InitializeLayerManager(aBackendHints);
|
|
mWidget = nullptr;
|
|
|
|
if (!mLayerManager) {
|
|
NS_WARNING("Failed to initialise Compositor");
|
|
*aSuccess = false;
|
|
LayerTransactionParent* p = new LayerTransactionParent(nullptr, this, 0);
|
|
p->AddIPDLReference();
|
|
return p;
|
|
}
|
|
|
|
mCompositionManager = new AsyncCompositionManager(mLayerManager);
|
|
*aSuccess = true;
|
|
|
|
*aTextureFactoryIdentifier = mCompositor->GetTextureFactoryIdentifier();
|
|
LayerTransactionParent* p = new LayerTransactionParent(mLayerManager, this, 0);
|
|
p->AddIPDLReference();
|
|
return p;
|
|
}
|
|
|
|
bool
|
|
CompositorParent::DeallocPLayerTransactionParent(PLayerTransactionParent* actor)
|
|
{
|
|
static_cast<LayerTransactionParent*>(actor)->ReleaseIPDLReference();
|
|
return true;
|
|
}
|
|
|
|
|
|
typedef map<uint64_t,CompositorParent*> CompositorMap;
|
|
static CompositorMap* sCompositorMap;
|
|
|
|
void CompositorParent::CreateCompositorMap()
|
|
{
|
|
if (sCompositorMap == nullptr) {
|
|
sCompositorMap = new CompositorMap;
|
|
}
|
|
}
|
|
|
|
void CompositorParent::DestroyCompositorMap()
|
|
{
|
|
if (sCompositorMap != nullptr) {
|
|
NS_ASSERTION(sCompositorMap->empty(),
|
|
"The Compositor map should be empty when destroyed>");
|
|
delete sCompositorMap;
|
|
sCompositorMap = nullptr;
|
|
}
|
|
}
|
|
|
|
CompositorParent* CompositorParent::GetCompositor(uint64_t id)
|
|
{
|
|
CompositorMap::iterator it = sCompositorMap->find(id);
|
|
return it != sCompositorMap->end() ? it->second : nullptr;
|
|
}
|
|
|
|
void CompositorParent::AddCompositor(CompositorParent* compositor, uint64_t* outID)
|
|
{
|
|
static uint64_t sNextID = 1;
|
|
|
|
++sNextID;
|
|
(*sCompositorMap)[sNextID] = compositor;
|
|
*outID = sNextID;
|
|
}
|
|
|
|
CompositorParent* CompositorParent::RemoveCompositor(uint64_t id)
|
|
{
|
|
CompositorMap::iterator it = sCompositorMap->find(id);
|
|
if (it == sCompositorMap->end()) {
|
|
return nullptr;
|
|
}
|
|
CompositorParent *retval = it->second;
|
|
sCompositorMap->erase(it);
|
|
return retval;
|
|
}
|
|
|
|
bool
|
|
CompositorParent::RecvNotifyChildCreated(const uint64_t& child)
|
|
{
|
|
NotifyChildCreated(child);
|
|
return true;
|
|
}
|
|
|
|
void
|
|
CompositorParent::NotifyChildCreated(uint64_t aChild)
|
|
{
|
|
sIndirectLayerTrees[aChild].mParent = this;
|
|
sIndirectLayerTrees[aChild].mLayerManager = mLayerManager;
|
|
}
|
|
|
|
/*static*/ uint64_t
|
|
CompositorParent::AllocateLayerTreeId()
|
|
{
|
|
MOZ_ASSERT(CompositorLoop());
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
static uint64_t ids = 0;
|
|
return ++ids;
|
|
}
|
|
|
|
static void
|
|
EraseLayerState(uint64_t aId)
|
|
{
|
|
sIndirectLayerTrees.erase(aId);
|
|
}
|
|
|
|
/*static*/ void
|
|
CompositorParent::DeallocateLayerTreeId(uint64_t aId)
|
|
{
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
CompositorLoop()->PostTask(FROM_HERE,
|
|
NewRunnableFunction(&EraseLayerState, aId));
|
|
}
|
|
|
|
static void
|
|
UpdateControllerForLayersId(uint64_t aLayersId,
|
|
GeckoContentController* aController)
|
|
{
|
|
// Adopt ref given to us by SetControllerForLayerTree()
|
|
sIndirectLayerTrees[aLayersId].mController =
|
|
already_AddRefed<GeckoContentController>(aController);
|
|
}
|
|
|
|
ScopedLayerTreeRegistration::ScopedLayerTreeRegistration(uint64_t aLayersId,
|
|
Layer* aRoot,
|
|
GeckoContentController* aController)
|
|
: mLayersId(aLayersId)
|
|
{
|
|
sIndirectLayerTrees[aLayersId].mRoot = aRoot;
|
|
sIndirectLayerTrees[aLayersId].mController = aController;
|
|
}
|
|
|
|
ScopedLayerTreeRegistration::~ScopedLayerTreeRegistration()
|
|
{
|
|
sIndirectLayerTrees.erase(mLayersId);
|
|
}
|
|
|
|
/*static*/ void
|
|
CompositorParent::SetControllerForLayerTree(uint64_t aLayersId,
|
|
GeckoContentController* aController)
|
|
{
|
|
// This ref is adopted by UpdateControllerForLayersId().
|
|
aController->AddRef();
|
|
CompositorLoop()->PostTask(FROM_HERE,
|
|
NewRunnableFunction(&UpdateControllerForLayersId,
|
|
aLayersId,
|
|
aController));
|
|
}
|
|
|
|
/*static*/ APZCTreeManager*
|
|
CompositorParent::GetAPZCTreeManager(uint64_t aLayersId)
|
|
{
|
|
const CompositorParent::LayerTreeState* state = CompositorParent::GetIndirectShadowTree(aLayersId);
|
|
if (state && state->mParent) {
|
|
return state->mParent->mApzcTreeManager;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
float
|
|
CompositorParent::ComputeRenderIntegrity()
|
|
{
|
|
if (mLayerManager) {
|
|
return mLayerManager->ComputeRenderIntegrity();
|
|
}
|
|
|
|
return 1.0f;
|
|
}
|
|
|
|
|
|
/**
|
|
* This class handles layer updates pushed directly from child
|
|
* processes to the compositor thread. It's associated with a
|
|
* CompositorParent on the compositor thread. While it uses the
|
|
* PCompositor protocol to manage these updates, it doesn't actually
|
|
* drive compositing itself. For that it hands off work to the
|
|
* CompositorParent it's associated with.
|
|
*/
|
|
class CrossProcessCompositorParent : public PCompositorParent,
|
|
public ShadowLayersManager
|
|
{
|
|
friend class CompositorParent;
|
|
|
|
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(CrossProcessCompositorParent)
|
|
public:
|
|
CrossProcessCompositorParent(Transport* aTransport)
|
|
: mTransport(aTransport)
|
|
{}
|
|
virtual ~CrossProcessCompositorParent();
|
|
|
|
// IToplevelProtocol::CloneToplevel()
|
|
virtual IToplevelProtocol*
|
|
CloneToplevel(const InfallibleTArray<mozilla::ipc::ProtocolFdMapping>& aFds,
|
|
base::ProcessHandle aPeerProcess,
|
|
mozilla::ipc::ProtocolCloneContext* aCtx) MOZ_OVERRIDE;
|
|
|
|
virtual void ActorDestroy(ActorDestroyReason aWhy) MOZ_OVERRIDE;
|
|
|
|
// FIXME/bug 774388: work out what shutdown protocol we need.
|
|
virtual bool RecvWillStop() MOZ_OVERRIDE { return true; }
|
|
virtual bool RecvStop() MOZ_OVERRIDE { return true; }
|
|
virtual bool RecvPause() MOZ_OVERRIDE { return true; }
|
|
virtual bool RecvResume() MOZ_OVERRIDE { return true; }
|
|
virtual bool RecvNotifyChildCreated(const uint64_t& child) MOZ_OVERRIDE;
|
|
virtual bool RecvMakeSnapshot(const SurfaceDescriptor& aInSnapshot,
|
|
SurfaceDescriptor* aOutSnapshot)
|
|
{ return true; }
|
|
virtual bool RecvFlushRendering() MOZ_OVERRIDE { return true; }
|
|
virtual bool RecvNotifyRegionInvalidated(const nsIntRegion& aRegion) { return true; }
|
|
virtual bool RecvStartFrameTimeRecording(const int32_t& aBufferSize, uint32_t* aOutStartIndex) MOZ_OVERRIDE { return true; }
|
|
virtual bool RecvStopFrameTimeRecording(const uint32_t& aStartIndex, InfallibleTArray<float>* intervals) MOZ_OVERRIDE { return true; }
|
|
virtual bool RecvSetTestSampleTime(const TimeStamp& aTime) MOZ_OVERRIDE { return true; }
|
|
virtual bool RecvLeaveTestMode() MOZ_OVERRIDE { return true; }
|
|
|
|
virtual PLayerTransactionParent*
|
|
AllocPLayerTransactionParent(const nsTArray<LayersBackend>& aBackendHints,
|
|
const uint64_t& aId,
|
|
TextureFactoryIdentifier* aTextureFactoryIdentifier,
|
|
bool *aSuccess) MOZ_OVERRIDE;
|
|
|
|
virtual bool DeallocPLayerTransactionParent(PLayerTransactionParent* aLayers) MOZ_OVERRIDE;
|
|
|
|
virtual void ShadowLayersUpdated(LayerTransactionParent* aLayerTree,
|
|
const TargetConfig& aTargetConfig,
|
|
bool aIsFirstPaint,
|
|
bool aScheduleComposite) MOZ_OVERRIDE;
|
|
virtual void ForceComposite(LayerTransactionParent* aLayerTree) MOZ_OVERRIDE;
|
|
|
|
virtual AsyncCompositionManager* GetCompositionManager(LayerTransactionParent* aParent) MOZ_OVERRIDE;
|
|
|
|
private:
|
|
void DeferredDestroy();
|
|
|
|
// There can be many CPCPs, and IPDL-generated code doesn't hold a
|
|
// reference to top-level actors. So we hold a reference to
|
|
// ourself. This is released (deferred) in ActorDestroy().
|
|
nsRefPtr<CrossProcessCompositorParent> mSelfRef;
|
|
Transport* mTransport;
|
|
};
|
|
|
|
static void
|
|
OpenCompositor(CrossProcessCompositorParent* aCompositor,
|
|
Transport* aTransport, ProcessHandle aHandle,
|
|
MessageLoop* aIOLoop)
|
|
{
|
|
DebugOnly<bool> ok = aCompositor->Open(aTransport, aHandle, aIOLoop);
|
|
MOZ_ASSERT(ok);
|
|
}
|
|
|
|
/*static*/ PCompositorParent*
|
|
CompositorParent::Create(Transport* aTransport, ProcessId aOtherProcess)
|
|
{
|
|
nsRefPtr<CrossProcessCompositorParent> cpcp =
|
|
new CrossProcessCompositorParent(aTransport);
|
|
ProcessHandle handle;
|
|
if (!base::OpenProcessHandle(aOtherProcess, &handle)) {
|
|
// XXX need to kill |aOtherProcess|, it's boned
|
|
return nullptr;
|
|
}
|
|
cpcp->mSelfRef = cpcp;
|
|
CompositorLoop()->PostTask(
|
|
FROM_HERE,
|
|
NewRunnableFunction(OpenCompositor, cpcp.get(),
|
|
aTransport, handle, XRE_GetIOMessageLoop()));
|
|
// The return value is just compared to null for success checking,
|
|
// we're not sharing a ref.
|
|
return cpcp.get();
|
|
}
|
|
|
|
IToplevelProtocol*
|
|
CompositorParent::CloneToplevel(const InfallibleTArray<mozilla::ipc::ProtocolFdMapping>& aFds,
|
|
base::ProcessHandle aPeerProcess,
|
|
mozilla::ipc::ProtocolCloneContext* aCtx)
|
|
{
|
|
for (unsigned int i = 0; i < aFds.Length(); i++) {
|
|
if (aFds[i].protocolId() == (unsigned)GetProtocolId()) {
|
|
Transport* transport = OpenDescriptor(aFds[i].fd(),
|
|
Transport::MODE_SERVER);
|
|
PCompositorParent* compositor = Create(transport, base::GetProcId(aPeerProcess));
|
|
compositor->CloneManagees(this, aCtx);
|
|
compositor->IToplevelProtocol::SetTransport(transport);
|
|
return compositor;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
static void
|
|
UpdateIndirectTree(uint64_t aId, Layer* aRoot, const TargetConfig& aTargetConfig)
|
|
{
|
|
sIndirectLayerTrees[aId].mRoot = aRoot;
|
|
sIndirectLayerTrees[aId].mTargetConfig = aTargetConfig;
|
|
}
|
|
|
|
/* static */ const CompositorParent::LayerTreeState*
|
|
CompositorParent::GetIndirectShadowTree(uint64_t aId)
|
|
{
|
|
LayerTreeMap::const_iterator cit = sIndirectLayerTrees.find(aId);
|
|
if (sIndirectLayerTrees.end() == cit) {
|
|
return nullptr;
|
|
}
|
|
return &cit->second;
|
|
}
|
|
|
|
static void
|
|
RemoveIndirectTree(uint64_t aId)
|
|
{
|
|
sIndirectLayerTrees.erase(aId);
|
|
}
|
|
|
|
void
|
|
CrossProcessCompositorParent::ActorDestroy(ActorDestroyReason aWhy)
|
|
{
|
|
MessageLoop::current()->PostTask(
|
|
FROM_HERE,
|
|
NewRunnableMethod(this, &CrossProcessCompositorParent::DeferredDestroy));
|
|
}
|
|
|
|
PLayerTransactionParent*
|
|
CrossProcessCompositorParent::AllocPLayerTransactionParent(const nsTArray<LayersBackend>&,
|
|
const uint64_t& aId,
|
|
TextureFactoryIdentifier* aTextureFactoryIdentifier,
|
|
bool *aSuccess)
|
|
{
|
|
MOZ_ASSERT(aId != 0);
|
|
|
|
if (sIndirectLayerTrees[aId].mLayerManager) {
|
|
sIndirectLayerTrees[aId].mCrossProcessParent = this;
|
|
LayerManagerComposite* lm = sIndirectLayerTrees[aId].mLayerManager;
|
|
*aTextureFactoryIdentifier = lm->GetCompositor()->GetTextureFactoryIdentifier();
|
|
*aSuccess = true;
|
|
LayerTransactionParent* p = new LayerTransactionParent(lm, this, aId);
|
|
p->AddIPDLReference();
|
|
return p;
|
|
}
|
|
|
|
NS_WARNING("Created child without a matching parent?");
|
|
// XXX: should be false, but that causes us to fail some tests on Mac w/ OMTC.
|
|
// Bug 900745. change *aSuccess to false to see test failures.
|
|
*aSuccess = true;
|
|
LayerTransactionParent* p = new LayerTransactionParent(nullptr, this, aId);
|
|
p->AddIPDLReference();
|
|
return p;
|
|
}
|
|
|
|
bool
|
|
CrossProcessCompositorParent::DeallocPLayerTransactionParent(PLayerTransactionParent* aLayers)
|
|
{
|
|
LayerTransactionParent* slp = static_cast<LayerTransactionParent*>(aLayers);
|
|
RemoveIndirectTree(slp->GetId());
|
|
static_cast<LayerTransactionParent*>(aLayers)->ReleaseIPDLReference();
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
CrossProcessCompositorParent::RecvNotifyChildCreated(const uint64_t& child)
|
|
{
|
|
sIndirectLayerTrees[child].mParent->NotifyChildCreated(child);
|
|
return true;
|
|
}
|
|
|
|
void
|
|
CrossProcessCompositorParent::ShadowLayersUpdated(
|
|
LayerTransactionParent* aLayerTree,
|
|
const TargetConfig& aTargetConfig,
|
|
bool aIsFirstPaint,
|
|
bool aScheduleComposite)
|
|
{
|
|
uint64_t id = aLayerTree->GetId();
|
|
MOZ_ASSERT(id != 0);
|
|
Layer* shadowRoot = aLayerTree->GetRoot();
|
|
if (shadowRoot) {
|
|
SetShadowProperties(shadowRoot);
|
|
}
|
|
UpdateIndirectTree(id, shadowRoot, aTargetConfig);
|
|
|
|
sIndirectLayerTrees[id].mParent->NotifyShadowTreeTransaction(id, aIsFirstPaint, aScheduleComposite);
|
|
}
|
|
|
|
void
|
|
CrossProcessCompositorParent::ForceComposite(LayerTransactionParent* aLayerTree)
|
|
{
|
|
uint64_t id = aLayerTree->GetId();
|
|
MOZ_ASSERT(id != 0);
|
|
sIndirectLayerTrees[id].mParent->ForceComposite(aLayerTree);
|
|
}
|
|
|
|
AsyncCompositionManager*
|
|
CrossProcessCompositorParent::GetCompositionManager(LayerTransactionParent* aLayerTree)
|
|
{
|
|
uint64_t id = aLayerTree->GetId();
|
|
return sIndirectLayerTrees[id].mParent->GetCompositionManager(aLayerTree);
|
|
}
|
|
|
|
void
|
|
CrossProcessCompositorParent::DeferredDestroy()
|
|
{
|
|
mSelfRef = nullptr;
|
|
// |this| was just destroyed, hands off
|
|
}
|
|
|
|
CrossProcessCompositorParent::~CrossProcessCompositorParent()
|
|
{
|
|
XRE_GetIOMessageLoop()->PostTask(FROM_HERE,
|
|
new DeleteTask<Transport>(mTransport));
|
|
}
|
|
|
|
IToplevelProtocol*
|
|
CrossProcessCompositorParent::CloneToplevel(const InfallibleTArray<mozilla::ipc::ProtocolFdMapping>& aFds,
|
|
base::ProcessHandle aPeerProcess,
|
|
mozilla::ipc::ProtocolCloneContext* aCtx)
|
|
{
|
|
for (unsigned int i = 0; i < aFds.Length(); i++) {
|
|
if (aFds[i].protocolId() == (unsigned)GetProtocolId()) {
|
|
Transport* transport = OpenDescriptor(aFds[i].fd(),
|
|
Transport::MODE_SERVER);
|
|
PCompositorParent* compositor =
|
|
CompositorParent::Create(transport, base::GetProcId(aPeerProcess));
|
|
compositor->CloneManagees(this, aCtx);
|
|
compositor->IToplevelProtocol::SetTransport(transport);
|
|
return compositor;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
} // namespace layers
|
|
} // namespace mozilla
|