already_AddRefed<ImageContainerChild> ImageBridgeChild::CreateImageContainerChild()
{
if (InImageBridgeChildThread()) {
return ImageBridgeChild::CreateImageContainerChildNow();
}
// ImageContainerChild can only be alocated on the ImageBridgeChild thread, so se
// dispatch a task to the thread and block the current thread until the task has been
// executed.
nsRefPtr<ImageContainerChild> result = nullptr;
ReentrantMonitor barrier("CreateImageContainerChild Lock");
ReentrantMonitorAutoEnter autoMon(barrier);
bool done = false;
GetMessageLoop()->PostTask(FROM_HERE, NewRunnableFunction(&CreateContainerChildSync,
&result, &barrier, &done));
// should stop the thread until the ImageContainerChild has been created on
// the other thread
while (!done) {
barrier.Wait();
}
return result.forget();
}
void ImageContainerChild::DispatchSetIdle()
{
if (mStop) return;
GetMessageLoop()->PostTask(FROM_HERE,
NewRunnableMethod(this, &ImageContainerChild::SetIdleNow));
}
void ImageContainerChild::SendImageAsync(ImageContainer* aContainer,
Image* aImage)
{
if(!aContainer || !aImage) {
return;
}
if (mStop) {
return;
}
if (InImageBridgeChildThread()) {
SharedImage *img = ImageToSharedImage(aImage);
if (img) {
SendPublishImage(*img);
} else {
NS_WARNING("Failed to create a shared image!");
}
delete img;
return;
}
// Sending images and (potentially) allocating shmems must be done
// on the ImageBridgeChild thread.
Task *t = new ImageBridgeCopyAndSendTask(this, aContainer, aImage);
GetMessageLoop()->PostTask(FROM_HERE, t);
}
void ImageContainerChild::DispatchDestroy()
{
NS_ABORT_IF_FALSE(mStop, "The state should be 'stopped' when destroying");
if (mDispatchedDestroy) {
return;
}
mDispatchedDestroy = true;
AddRef(); // corresponds to the Release in DestroyNow
GetMessageLoop()->PostTask(FROM_HERE,
NewRunnableMethod(this, &ImageContainerChild::DestroyNow));
}
void ImageContainerChild::Destroy()
{
if (mStop) return;
mStop = true;
if (mImageContainer) {
mImageContainer->SetImageContainerChild(nsnull);
}
if (InImageBridgeChildThread()) {
DestroyNow();
return;
}
// destruction must be done on the ImageBridgeChild thread
Task * t = new ImageContainerChildDestroyTask(this);
GetMessageLoop()->PostTask(FROM_HERE, t);
}
void ImageContainerChild::SetIdle()
{
if (mStop) return;
if (InImageBridgeChildThread()) {
return SetIdleNow();
}
Monitor barrier("SetIdle Lock");
MonitorAutoLock autoMon(barrier);
bool done = false;
GetMessageLoop()->PostTask(FROM_HERE,
NewRunnableMethod(this, &ImageContainerChild::SetIdleSync, &barrier, &done));
while (!done) {
barrier.Wait();
}
}
bool
ImageBridgeChild::DeallocSurfaceDescriptorGralloc(const SurfaceDescriptor& aBuffer)
{
if (InImageBridgeChildThread()) {
return ImageBridgeChild::DeallocSurfaceDescriptorGrallocNow(aBuffer);
}
Monitor barrier("DeallocSurfaceDescriptor Lock");
MonitorAutoLock autoMon(barrier);
bool done = false;
GetMessageLoop()->PostTask(FROM_HERE, NewRunnableFunction(&DeallocSurfaceDescriptorGrallocSync,
aBuffer, &barrier, &done));
while (!done) {
barrier.Wait();
}
return true;
}
TemporaryRef<ImageClient>
ImageBridgeChild::CreateImageClient(CompositableType aType)
{
if (InImageBridgeChildThread()) {
return CreateImageClientNow(aType);
}
ReentrantMonitor barrier("CreateImageClient Lock");
ReentrantMonitorAutoEnter autoMon(barrier);
bool done = false;
RefPtr<ImageClient> result = nullptr;
GetMessageLoop()->PostTask(FROM_HERE, NewRunnableFunction(&CreateImageClientSync,
&result, &barrier, aType, &done));
// should stop the thread until the ImageClient has been created on
// the other thread
while (!done) {
barrier.Wait();
}
return result.forget();
}
void ImageContainerChild::SendImageAsync(ImageContainer* aContainer,
Image* aImage)
{
if(!aContainer || !aImage) {
return;
}
if (mStop) {
return;
}
if (InImageBridgeChildThread()) {
SendImageNow(aImage);
}
// Sending images and (potentially) allocating shmems must be done
// on the ImageBridgeChild thread.
Task *t = new ImageBridgeCopyAndSendTask(this, aContainer, aImage);
GetMessageLoop()->PostTask(FROM_HERE, t);
}
void
ImageBridgeChild::DeallocShmem(ipc::Shmem& aShmem)
{
if (InImageBridgeChildThread()) {
PImageBridgeChild::DeallocShmem(aShmem);
} else {
ReentrantMonitor barrier("AllocatorProxy Dealloc");
ReentrantMonitorAutoEnter autoMon(barrier);
bool done = false;
GetMessageLoop()->PostTask(FROM_HERE,
NewRunnableFunction(&ProxyDeallocShmemNow,
this,
&aShmem,
&barrier,
&done));
while (!done) {
barrier.Wait();
}
}
}
bool
ImageBridgeChild::AllocSurfaceDescriptorGralloc(const gfxIntSize& aSize,
const uint32_t& aFormat,
const uint32_t& aUsage,
SurfaceDescriptor* aBuffer)
{
if (InImageBridgeChildThread()) {
return ImageBridgeChild::AllocSurfaceDescriptorGrallocNow(aSize, aFormat, aUsage, aBuffer);
}
Monitor barrier("AllocSurfaceDescriptorGralloc Lock");
MonitorAutoLock autoMon(barrier);
bool done = false;
GetMessageLoop()->PostTask(
FROM_HERE,
NewRunnableFunction(&AllocSurfaceDescriptorGrallocSync,
GrallocParam(aSize, aFormat, aUsage, aBuffer), &barrier, &done));
while (!done) {
barrier.Wait();
}
return true;
}
bool
ImageBridgeChild::DispatchAllocShmemInternal(size_t aSize,
SharedMemory::SharedMemoryType aType,
Shmem* aShmem,
bool aUnsafe)
{
ReentrantMonitor barrier("AllocatorProxy alloc");
ReentrantMonitorAutoEnter autoMon(barrier);
AllocShmemParams params = {
this, aSize, aType, aShmem, aUnsafe, true
};
bool done = false;
GetMessageLoop()->PostTask(FROM_HERE,
NewRunnableFunction(&ProxyAllocShmemNow,
¶ms,
&barrier,
&done));
while (!done) {
barrier.Wait();
}
return params.mSuccess;
}
void ImageBridgeChild::ConnectAsync(ImageBridgeParent* aParent)
{
GetMessageLoop()->PostTask(FROM_HERE, NewRunnableFunction(&ConnectImageBridge,
this, aParent));
}
void ImageContainerChild::DispatchStop()
{
GetMessageLoop()->PostTask(FROM_HERE,
NewRunnableMethod(this, &ImageContainerChild::StopChildAndParent));
}
