mozilla::ipc::IPCResult
DocAccessibleParent::RecvShutdown()
{
Destroy();
auto mgr = static_cast<dom::TabParent*>(Manager());
if (!mgr->IsDestroyed()) {
if (!PDocAccessibleParent::Send__delete__(this)) {
return IPC_FAIL_NO_REASON(mgr);
}
}
return IPC_OK();
}
mozilla::ipc::IPCResult
WebRenderBridgeParent::RecvSetAsyncZoom(const FrameMetrics::ViewID& aScrollId,
const float& aZoom)
{
if (mDestroyed) {
return IPC_OK();
}
RefPtr<AsyncPanZoomController> apzc = GetTargetAPZC(aScrollId);
if (!apzc) {
return IPC_FAIL_NO_REASON(this);
}
apzc->SetTestAsyncZoom(LayerToParentLayerScale(aZoom));
return IPC_OK();
}
mozilla::ipc::IPCResult
GMPDecryptorChild::RecvSetServerCertificate(const uint32_t& aPromiseId,
InfallibleTArray<uint8_t>&& aServerCert)
{
if (!mSession) {
return IPC_FAIL_NO_REASON(this);
}
mSession->SetServerCertificate(aPromiseId,
aServerCert.Elements(),
aServerCert.Length());
return IPC_OK();
}
mozilla::ipc::IPCResult
GMPDecryptorParent::RecvSetSessionId(const uint32_t& aCreateSessionId,
const nsCString& aSessionId)
{
LOGD(("GMPDecryptorParent[%p]::RecvSetSessionId(token=%u, sessionId='%s')",
this, aCreateSessionId, aSessionId.get()));
if (!mIsOpen) {
NS_WARNING("Trying to use a dead GMP decrypter!");
return IPC_FAIL_NO_REASON(this);
}
mCallback->SetSessionId(aCreateSessionId, aSessionId);
return IPC_OK();
}
mozilla::ipc::IPCResult
GMPVideoDecoderParent::RecvInputDataExhausted()
{
LOGV(("GMPVideoDecoderParent[%p]::RecvInputDataExhausted()", this));
if (!mCallback) {
return IPC_FAIL_NO_REASON(this);
}
// Ignore any return code. It is OK for this to fail without killing the process.
mCallback->InputDataExhausted();
return IPC_OK();
}
mozilla::ipc::IPCResult
GMPDecryptorParent::RecvExpirationChange(const nsCString& aSessionId,
const double& aSecondsSinceEpoch)
{
LOGD(("GMPDecryptorParent[%p]::RecvExpirationChange(sessionId='%s', expiry=%lf)",
this, aSessionId.get(), aSecondsSinceEpoch));
if (!mIsOpen) {
NS_WARNING("Trying to use a dead GMP decrypter!");
return IPC_FAIL_NO_REASON(this);
}
mCallback->ExpirationChange(aSessionId, aSecondsSinceEpoch);
return IPC_OK();
}
mozilla::ipc::IPCResult
GMPDecryptorChild::RecvRemoveSession(const uint32_t& aPromiseId,
const nsCString& aSessionId)
{
if (!mSession) {
return IPC_FAIL_NO_REASON(this);
}
mSession->RemoveSession(aPromiseId,
aSessionId.get(),
aSessionId.Length());
return IPC_OK();
}
mozilla::ipc::IPCResult
GMPDecryptorParent::RecvResolveLoadSessionPromise(const uint32_t& aPromiseId,
const bool& aSuccess)
{
LOGD(("GMPDecryptorParent[%p]::RecvResolveLoadSessionPromise(promiseId=%u)",
this, aPromiseId));
if (!mIsOpen) {
NS_WARNING("Trying to use a dead GMP decrypter!");
return IPC_FAIL_NO_REASON(this);
}
mCallback->ResolveLoadSessionPromise(aPromiseId, aSuccess);
return IPC_OK();
}
mozilla::ipc::IPCResult
GMPVideoDecoderParent::RecvDecoded(const GMPVideoi420FrameData& aDecodedFrame)
{
--mFrameCount;
LOGV(("GMPVideoDecoderParent[%p]::RecvDecoded() timestamp=%lld frameCount=%d",
this, aDecodedFrame.mTimestamp(), mFrameCount));
if (!mCallback) {
return IPC_FAIL_NO_REASON(this);
}
if (!GMPVideoi420FrameImpl::CheckFrameData(aDecodedFrame)) {
LOGE(("GMPVideoDecoderParent[%p]::RecvDecoded() "
"timestamp=%lld decoded frame corrupt, ignoring"));
return IPC_FAIL_NO_REASON(this);
}
auto f = new GMPVideoi420FrameImpl(aDecodedFrame, &mVideoHost);
// Ignore any return code. It is OK for this to fail without killing the process.
mCallback->Decoded(f);
return IPC_OK();
}
mozilla::ipc::IPCResult
WebRenderBridgeParent::RecvAddPipelineIdForCompositable(const wr::PipelineId& aPipelineId,
const CompositableHandle& aHandle,
const bool& aAsync)
{
if (mDestroyed) {
return IPC_OK();
}
MOZ_ASSERT(!mAsyncCompositables.Get(wr::AsUint64(aPipelineId)).get());
RefPtr<CompositableHost> host;
if (aAsync) {
RefPtr<ImageBridgeParent> imageBridge = ImageBridgeParent::GetInstance(OtherPid());
if (!imageBridge) {
return IPC_FAIL_NO_REASON(this);
}
host = imageBridge->FindCompositable(aHandle);
} else {
host = FindCompositable(aHandle);
}
if (!host) {
return IPC_FAIL_NO_REASON(this);
}
MOZ_ASSERT(host->AsWebRenderImageHost());
WebRenderImageHost* wrHost = host->AsWebRenderImageHost();
if (!wrHost) {
return IPC_OK();
}
wrHost->SetWrBridge(this);
mAsyncCompositables.Put(wr::AsUint64(aPipelineId), wrHost);
mAsyncImageManager->AddAsyncImagePipeline(aPipelineId, wrHost);
return IPC_OK();
}
mozilla::ipc::IPCResult
WebRenderBridgeParent::RecvSetAsyncScrollOffset(const FrameMetrics::ViewID& aScrollId,
const float& aX,
const float& aY)
{
if (mDestroyed) {
return IPC_OK();
}
RefPtr<AsyncPanZoomController> apzc = GetTargetAPZC(aScrollId);
if (!apzc) {
return IPC_FAIL_NO_REASON(this);
}
apzc->SetTestAsyncScrollOffset(CSSPoint(aX, aY));
return IPC_OK();
}
mozilla::ipc::IPCResult
CrossProcessCompositorBridgeParent::RecvAsyncPanZoomEnabled(const uint64_t& aLayersId, bool* aHasAPZ)
{
// Check to see if this child process has access to this layer tree.
if (!LayerTreeOwnerTracker::Get()->IsMapped(aLayersId, OtherPid())) {
NS_ERROR("Unexpected layers id in RecvAsyncPanZoomEnabled; dropping message...");
return IPC_FAIL_NO_REASON(this);
}
MonitorAutoLock lock(*sIndirectLayerTreesLock);
CompositorBridgeParent::LayerTreeState& state = sIndirectLayerTrees[aLayersId];
*aHasAPZ = state.mParent ? state.mParent->AsyncPanZoomEnabled() : false;
return IPC_OK();
}
mozilla::ipc::IPCResult
GMPDecryptorParent::RecvRejectPromise(const uint32_t& aPromiseId,
const GMPDOMException& aException,
const nsCString& aMessage)
{
LOGD(("GMPDecryptorParent[%p]::RecvRejectPromise(promiseId=%u, exception=%d, msg='%s')",
this, aPromiseId, aException, aMessage.get()));
if (!mIsOpen) {
NS_WARNING("Trying to use a dead GMP decrypter!");
return IPC_FAIL_NO_REASON(this);
}
mCallback->RejectPromise(aPromiseId, GMPExToNsresult(aException), aMessage);
return IPC_OK();
}
mozilla::ipc::IPCResult
DocAccessibleParent::RecvRoleChangedEvent(const uint32_t& aRole)
{
if (mShutdown) {
return IPC_OK();
}
if (aRole >= roles::LAST_ROLE) {
NS_ERROR("child sent bad role in RoleChangedEvent");
return IPC_FAIL_NO_REASON(this);
}
mRole = static_cast<a11y::role>(aRole);
return IPC_OK();
}
mozilla::ipc::IPCResult
GMPDecryptorParent::RecvSessionMessage(const nsCString& aSessionId,
const GMPSessionMessageType& aMessageType,
nsTArray<uint8_t>&& aMessage)
{
LOGD(("GMPDecryptorParent[%p]::RecvSessionMessage(sessionId='%s', type=%d, msg='%s')",
this, aSessionId.get(), aMessageType, ToBase64(aMessage).get()));
if (!mIsOpen) {
NS_WARNING("Trying to use a dead GMP decrypter!");
return IPC_FAIL_NO_REASON(this);
}
mCallback->SessionMessage(aSessionId, ToMediaKeyMessageType(aMessageType), aMessage);
return IPC_OK();
}
mozilla::ipc::IPCResult
GMPDecryptorParent::RecvDecrypted(const uint32_t& aId,
const GMPErr& aErr,
InfallibleTArray<uint8_t>&& aBuffer)
{
LOGV(("GMPDecryptorParent[%p]::RecvDecrypted(id=%d, err=%d)",
this, aId, aErr));
if (!mIsOpen) {
NS_WARNING("Trying to use a dead GMP decrypter!");
return IPC_FAIL_NO_REASON(this);
}
mCallback->Decrypted(aId, ToDecryptStatus(aErr), aBuffer);
return IPC_OK();
}
mozilla::ipc::IPCResult
GamepadTestChannelParent::RecvGamepadTestEvent(const uint32_t& aID,
const GamepadChangeEvent& aEvent)
{
mozilla::ipc::AssertIsOnBackgroundThread();
RefPtr<GamepadPlatformService> service =
GamepadPlatformService::GetParentService();
MOZ_ASSERT(service);
if (aEvent.type() == GamepadChangeEvent::TGamepadAdded) {
const GamepadAdded& a = aEvent.get_GamepadAdded();
nsCString gamepadID;
LossyCopyUTF16toASCII(a.id(), gamepadID);
uint32_t index = service->AddGamepad(gamepadID.get(),
static_cast<GamepadMappingType>(a.mapping()),
a.hand(),
a.num_buttons(),
a.num_axes(),
a.num_haptics());
if (!mShuttingdown) {
Unused << SendReplyGamepadIndex(aID, index);
}
return IPC_OK();
}
if (aEvent.type() == GamepadChangeEvent::TGamepadRemoved) {
const GamepadRemoved& a = aEvent.get_GamepadRemoved();
service->RemoveGamepad(a.index());
return IPC_OK();
}
if (aEvent.type() == GamepadChangeEvent::TGamepadButtonInformation) {
const GamepadButtonInformation& a = aEvent.get_GamepadButtonInformation();
service->NewButtonEvent(a.index(), a.button(), a.pressed(), a.touched(),
a.value());
return IPC_OK();
}
if (aEvent.type() == GamepadChangeEvent::TGamepadAxisInformation) {
const GamepadAxisInformation& a = aEvent.get_GamepadAxisInformation();
service->NewAxisMoveEvent(a.index(), a.axis(), a.value());
return IPC_OK();
}
if (aEvent.type() == GamepadChangeEvent::TGamepadPoseInformation) {
const GamepadPoseInformation& a = aEvent.get_GamepadPoseInformation();
service->NewPoseEvent(a.index(), a.pose_state());
return IPC_OK();
}
NS_WARNING("Unknown event type.");
return IPC_FAIL_NO_REASON(this);
}
mozilla::ipc::IPCResult
BroadcastChannelParent::RecvClose()
{
AssertIsOnBackgroundThread();
if (NS_WARN_IF(!mService)) {
return IPC_FAIL_NO_REASON(this);
}
mService->UnregisterActor(this, mOriginChannelKey);
mService = nullptr;
Unused << Send__delete__(this);
return IPC_OK();
}
mozilla::ipc::IPCResult
CrossProcessCompositorBridgeParent::RecvNotifyChildCreated(const uint64_t& child,
CompositorOptions* aOptions)
{
MonitorAutoLock lock(*sIndirectLayerTreesLock);
for (LayerTreeMap::iterator it = sIndirectLayerTrees.begin();
it != sIndirectLayerTrees.end(); it++) {
CompositorBridgeParent::LayerTreeState* lts = &it->second;
if (lts->mParent && lts->mCrossProcessParent == this) {
lts->mParent->NotifyChildCreated(child);
*aOptions = lts->mParent->GetOptions();
return IPC_OK();
}
}
return IPC_FAIL_NO_REASON(this);
}
mozilla::ipc::IPCResult
GMPDecryptorChild::RecvUpdateSession(const uint32_t& aPromiseId,
const nsCString& aSessionId,
InfallibleTArray<uint8_t>&& aResponse)
{
if (!mSession) {
return IPC_FAIL_NO_REASON(this);
}
mSession->UpdateSession(aPromiseId,
aSessionId.get(),
aSessionId.Length(),
aResponse.Elements(),
aResponse.Length());
return IPC_OK();
}
mozilla::ipc::IPCResult
CrossProcessCompositorBridgeParent::RecvNotifyApproximatelyVisibleRegion(const ScrollableLayerGuid& aGuid,
const CSSIntRegion& aRegion)
{
CompositorBridgeParent* parent;
{ // scope lock
MonitorAutoLock lock(*sIndirectLayerTreesLock);
parent = sIndirectLayerTrees[aGuid.mLayersId].mParent;
}
if (parent) {
if (!parent->RecvNotifyApproximatelyVisibleRegion(aGuid, aRegion)) {
return IPC_FAIL_NO_REASON(this);
}
return IPC_OK();;
}
return IPC_OK();
}
mozilla::ipc::IPCResult
GMPVideoDecoderChild::RecvInitDecode(const GMPVideoCodec& aCodecSettings,
InfallibleTArray<uint8_t>&& aCodecSpecific,
const int32_t& aCoreCount)
{
if (!mVideoDecoder) {
return IPC_FAIL_NO_REASON(this);
}
// Ignore any return code. It is OK for this to fail without killing the process.
mVideoDecoder->InitDecode(aCodecSettings,
aCodecSpecific.Elements(),
aCodecSpecific.Length(),
this,
aCoreCount);
return IPC_OK();
}
mozilla::ipc::IPCResult
GMPDecryptorChild::RecvDecryptingComplete()
{
// Reset |mSession| before calling DecryptingComplete(). We should not send
// any IPC messages during tear-down.
auto session = mSession;
mSession = nullptr;
if (!session) {
return IPC_FAIL_NO_REASON(this);
}
session->DecryptingComplete();
Unused << Send__delete__(this);
return IPC_OK();
}
mozilla::ipc::IPCResult
BrowserStreamParent::RecvNPN_DestroyStream(const NPReason& reason)
{
switch (mState) {
case ALIVE:
break;
case DYING:
return IPC_OK();
default:
NS_ERROR("Unexpected state");
return IPC_FAIL_NO_REASON(this);
}
mNPP->mNPNIface->destroystream(mNPP->mNPP, mStream, reason);
return IPC_OK();
}
mozilla::ipc::IPCResult
MessagePortParent::RecvClose()
{
if (mService) {
MOZ_ASSERT(mEntangled);
if (!mService->ClosePort(this)) {
return IPC_FAIL_NO_REASON(this);
}
Close();
}
MOZ_ASSERT(!mEntangled);
Unused << Send__delete__(this);
return IPC_OK();
}
mozilla::ipc::IPCResult
GMPVideoDecoderParent::AnswerNeedShmem(const uint32_t& aFrameBufferSize,
Shmem* aMem)
{
ipc::Shmem mem;
if (!mVideoHost.SharedMemMgr()->MgrAllocShmem(GMPSharedMem::kGMPFrameData,
aFrameBufferSize,
ipc::SharedMemory::TYPE_BASIC, &mem))
{
LOGE(("%s: Failed to get a shared mem buffer for Child! size %u",
__FUNCTION__, aFrameBufferSize));
return IPC_FAIL_NO_REASON(this);
}
*aMem = mem;
mem = ipc::Shmem();
return IPC_OK();
}
mozilla::ipc::IPCResult
GMPVideoEncoderParent::RecvEncoded(const GMPVideoEncodedFrameData& aEncodedFrame,
InfallibleTArray<uint8_t>&& aCodecSpecificInfo)
{
if (!mCallback) {
return IPC_FAIL_NO_REASON(this);
}
auto f = new GMPVideoEncodedFrameImpl(aEncodedFrame, &mVideoHost);
nsTArray<uint8_t> *codecSpecificInfo = new nsTArray<uint8_t>;
codecSpecificInfo->AppendElements((uint8_t*)aCodecSpecificInfo.Elements(), aCodecSpecificInfo.Length());
nsCOMPtr<nsIThread> thread = NS_GetCurrentThread();
mEncodedThread->Dispatch(WrapRunnableNM(&EncodedCallback,
mCallback, f, codecSpecificInfo, thread),
NS_DISPATCH_NORMAL);
return IPC_OK();
}
mozilla::ipc::IPCResult
GMPVideoDecoderParent::RecvError(const GMPErr& aError)
{
LOGD(("GMPVideoDecoderParent[%p]::RecvError(error=%d)", this, aError));
if (!mCallback) {
return IPC_FAIL_NO_REASON(this);
}
// Ensure if we've received an error while waiting for a ResetComplete
// or DrainComplete notification, we'll unblock the caller before processing
// the error.
UnblockResetAndDrain();
// Ignore any return code. It is OK for this to fail without killing the process.
mCallback->Error(aError);
return IPC_OK();
}
mozilla::ipc::IPCResult
VRManagerChild::RecvParentAsyncMessages(InfallibleTArray<AsyncParentMessageData>&& aMessages)
{
for (InfallibleTArray<AsyncParentMessageData>::index_type i = 0; i < aMessages.Length(); ++i) {
const AsyncParentMessageData& message = aMessages[i];
switch (message.type()) {
case AsyncParentMessageData::TOpNotifyNotUsed: {
const OpNotifyNotUsed& op = message.get_OpNotifyNotUsed();
NotifyNotUsed(op.TextureId(), op.fwdTransactionId());
break;
}
default:
NS_ERROR("unknown AsyncParentMessageData type");
return IPC_FAIL_NO_REASON(this);
}
}
return IPC_OK();
}
mozilla::ipc::IPCResult
WebRenderBridgeParent::RecvGetAnimationTransform(const uint64_t& aCompositorAnimationsId,
MaybeTransform* aTransform)
{
if (mDestroyed) {
return IPC_FAIL_NO_REASON(this);
}
MOZ_ASSERT(mAnimStorage);
AdvanceAnimations();
Maybe<Matrix4x4> transform = mAnimStorage->GetAnimationTransform(aCompositorAnimationsId);
if (transform) {
*aTransform = *transform;
} else {
*aTransform = mozilla::void_t();
}
return IPC_OK();
}
