diff options
Diffstat (limited to 'ipc/glue/BackgroundParentImpl.cpp')
| -rw-r--r-- | ipc/glue/BackgroundParentImpl.cpp | 848 |
1 files changed, 848 insertions, 0 deletions
diff --git a/ipc/glue/BackgroundParentImpl.cpp b/ipc/glue/BackgroundParentImpl.cpp new file mode 100644 index 000000000..ef5dc1cab --- /dev/null +++ b/ipc/glue/BackgroundParentImpl.cpp @@ -0,0 +1,848 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 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 "BackgroundParentImpl.h" + +#include "BroadcastChannelParent.h" +#include "FileDescriptorSetParent.h" +#ifdef MOZ_WEBRTC +#include "CamerasParent.h" +#endif +#include "mozilla/media/MediaParent.h" +#include "mozilla/AppProcessChecker.h" +#include "mozilla/Assertions.h" +#include "mozilla/dom/ContentParent.h" +#include "mozilla/dom/DOMTypes.h" +#include "mozilla/dom/FileSystemBase.h" +#include "mozilla/dom/FileSystemRequestParent.h" +#ifdef MOZ_GAMEPAD +#include "mozilla/dom/GamepadEventChannelParent.h" +#include "mozilla/dom/GamepadTestChannelParent.h" +#endif +#include "mozilla/dom/PBlobParent.h" +#include "mozilla/dom/PGamepadEventChannelParent.h" +#include "mozilla/dom/PGamepadTestChannelParent.h" +#include "mozilla/dom/MessagePortParent.h" +#include "mozilla/dom/ServiceWorkerRegistrar.h" +#include "mozilla/dom/asmjscache/AsmJSCache.h" +#include "mozilla/dom/cache/ActorUtils.h" +#include "mozilla/dom/indexedDB/ActorsParent.h" +#include "mozilla/dom/ipc/BlobParent.h" +#include "mozilla/dom/quota/ActorsParent.h" +#include "mozilla/ipc/BackgroundParent.h" +#include "mozilla/ipc/BackgroundUtils.h" +#include "mozilla/ipc/PBackgroundSharedTypes.h" +#include "mozilla/ipc/PBackgroundTestParent.h" +#include "mozilla/ipc/PSendStreamParent.h" +#include "mozilla/ipc/SendStreamAlloc.h" +#include "mozilla/layout/VsyncParent.h" +#include "mozilla/dom/network/UDPSocketParent.h" +#include "mozilla/Preferences.h" +#include "nsIAppsService.h" +#include "nsNetUtil.h" +#include "nsIScriptSecurityManager.h" +#include "nsProxyRelease.h" +#include "mozilla/RefPtr.h" +#include "nsThreadUtils.h" +#include "nsTraceRefcnt.h" +#include "nsXULAppAPI.h" +#include "ServiceWorkerManagerParent.h" + +#ifdef DISABLE_ASSERTS_FOR_FUZZING +#define ASSERT_UNLESS_FUZZING(...) do { } while (0) +#else +#define ASSERT_UNLESS_FUZZING(...) MOZ_ASSERT(false) +#endif + +using mozilla::ipc::AssertIsOnBackgroundThread; +using mozilla::dom::asmjscache::PAsmJSCacheEntryParent; +using mozilla::dom::cache::PCacheParent; +using mozilla::dom::cache::PCacheStorageParent; +using mozilla::dom::cache::PCacheStreamControlParent; +using mozilla::dom::FileSystemBase; +using mozilla::dom::FileSystemRequestParent; +using mozilla::dom::MessagePortParent; +using mozilla::dom::PMessagePortParent; +using mozilla::dom::UDPSocketParent; + +namespace { + +void +AssertIsOnMainThread() +{ + MOZ_ASSERT(NS_IsMainThread()); +} + +class TestParent final : public mozilla::ipc::PBackgroundTestParent +{ + friend class mozilla::ipc::BackgroundParentImpl; + + TestParent() + { + MOZ_COUNT_CTOR(TestParent); + } + +protected: + ~TestParent() + { + MOZ_COUNT_DTOR(TestParent); + } + +public: + virtual void + ActorDestroy(ActorDestroyReason aWhy) override; +}; + +} // namespace + +namespace mozilla { +namespace ipc { + +using mozilla::dom::ContentParent; +using mozilla::dom::BroadcastChannelParent; +using mozilla::dom::ServiceWorkerRegistrationData; +using mozilla::dom::workers::ServiceWorkerManagerParent; + +BackgroundParentImpl::BackgroundParentImpl() +{ + AssertIsInMainProcess(); + AssertIsOnMainThread(); + + MOZ_COUNT_CTOR(mozilla::ipc::BackgroundParentImpl); +} + +BackgroundParentImpl::~BackgroundParentImpl() +{ + AssertIsInMainProcess(); + AssertIsOnMainThread(); + + MOZ_COUNT_DTOR(mozilla::ipc::BackgroundParentImpl); +} + +void +BackgroundParentImpl::ActorDestroy(ActorDestroyReason aWhy) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); +} + +BackgroundParentImpl::PBackgroundTestParent* +BackgroundParentImpl::AllocPBackgroundTestParent(const nsCString& aTestArg) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + return new TestParent(); +} + +bool +BackgroundParentImpl::RecvPBackgroundTestConstructor( + PBackgroundTestParent* aActor, + const nsCString& aTestArg) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + MOZ_ASSERT(aActor); + + return PBackgroundTestParent::Send__delete__(aActor, aTestArg); +} + +bool +BackgroundParentImpl::DeallocPBackgroundTestParent( + PBackgroundTestParent* aActor) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + MOZ_ASSERT(aActor); + + delete static_cast<TestParent*>(aActor); + return true; +} + +auto +BackgroundParentImpl::AllocPBackgroundIDBFactoryParent( + const LoggingInfo& aLoggingInfo) + -> PBackgroundIDBFactoryParent* +{ + using mozilla::dom::indexedDB::AllocPBackgroundIDBFactoryParent; + + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + return AllocPBackgroundIDBFactoryParent(aLoggingInfo); +} + +bool +BackgroundParentImpl::RecvPBackgroundIDBFactoryConstructor( + PBackgroundIDBFactoryParent* aActor, + const LoggingInfo& aLoggingInfo) +{ + using mozilla::dom::indexedDB::RecvPBackgroundIDBFactoryConstructor; + + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + MOZ_ASSERT(aActor); + + return RecvPBackgroundIDBFactoryConstructor(aActor, aLoggingInfo); +} + +bool +BackgroundParentImpl::DeallocPBackgroundIDBFactoryParent( + PBackgroundIDBFactoryParent* aActor) +{ + using mozilla::dom::indexedDB::DeallocPBackgroundIDBFactoryParent; + + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + MOZ_ASSERT(aActor); + + return DeallocPBackgroundIDBFactoryParent(aActor); +} + +auto +BackgroundParentImpl::AllocPBackgroundIndexedDBUtilsParent() + -> PBackgroundIndexedDBUtilsParent* +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + return mozilla::dom::indexedDB::AllocPBackgroundIndexedDBUtilsParent(); +} + +bool +BackgroundParentImpl::DeallocPBackgroundIndexedDBUtilsParent( + PBackgroundIndexedDBUtilsParent* aActor) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + MOZ_ASSERT(aActor); + + return + mozilla::dom::indexedDB::DeallocPBackgroundIndexedDBUtilsParent(aActor); +} + +bool +BackgroundParentImpl::RecvFlushPendingFileDeletions() +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + return mozilla::dom::indexedDB::RecvFlushPendingFileDeletions(); +} + +auto +BackgroundParentImpl::AllocPBlobParent(const BlobConstructorParams& aParams) + -> PBlobParent* +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + if (NS_WARN_IF(aParams.type() != + BlobConstructorParams::TParentBlobConstructorParams)) { + ASSERT_UNLESS_FUZZING(); + return nullptr; + } + + return mozilla::dom::BlobParent::Create(this, aParams); +} + +bool +BackgroundParentImpl::DeallocPBlobParent(PBlobParent* aActor) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + MOZ_ASSERT(aActor); + + mozilla::dom::BlobParent::Destroy(aActor); + return true; +} + +bool +BackgroundParentImpl::RecvPBlobConstructor(PBlobParent* aActor, + const BlobConstructorParams& aParams) +{ + const ParentBlobConstructorParams& params = aParams; + if (params.blobParams().type() == AnyBlobConstructorParams::TKnownBlobConstructorParams) { + return aActor->SendCreatedFromKnownBlob(); + } + + return true; +} + +PFileDescriptorSetParent* +BackgroundParentImpl::AllocPFileDescriptorSetParent( + const FileDescriptor& aFileDescriptor) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + return new FileDescriptorSetParent(aFileDescriptor); +} + +bool +BackgroundParentImpl::DeallocPFileDescriptorSetParent( + PFileDescriptorSetParent* aActor) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + MOZ_ASSERT(aActor); + + delete static_cast<FileDescriptorSetParent*>(aActor); + return true; +} + +PSendStreamParent* +BackgroundParentImpl::AllocPSendStreamParent() +{ + return mozilla::ipc::AllocPSendStreamParent(); +} + +bool +BackgroundParentImpl::DeallocPSendStreamParent(PSendStreamParent* aActor) +{ + delete aActor; + return true; +} + +BackgroundParentImpl::PVsyncParent* +BackgroundParentImpl::AllocPVsyncParent() +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + RefPtr<mozilla::layout::VsyncParent> actor = + mozilla::layout::VsyncParent::Create(); + // There still has one ref-count after return, and it will be released in + // DeallocPVsyncParent(). + return actor.forget().take(); +} + +bool +BackgroundParentImpl::DeallocPVsyncParent(PVsyncParent* aActor) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + MOZ_ASSERT(aActor); + + // This actor already has one ref-count. Please check AllocPVsyncParent(). + RefPtr<mozilla::layout::VsyncParent> actor = + dont_AddRef(static_cast<mozilla::layout::VsyncParent*>(aActor)); + return true; +} + +camera::PCamerasParent* +BackgroundParentImpl::AllocPCamerasParent() +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + +#ifdef MOZ_WEBRTC + RefPtr<mozilla::camera::CamerasParent> actor = + mozilla::camera::CamerasParent::Create(); + return actor.forget().take(); +#else + return nullptr; +#endif +} + +bool +BackgroundParentImpl::DeallocPCamerasParent(camera::PCamerasParent *aActor) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + MOZ_ASSERT(aActor); + +#ifdef MOZ_WEBRTC + RefPtr<mozilla::camera::CamerasParent> actor = + dont_AddRef(static_cast<mozilla::camera::CamerasParent*>(aActor)); +#endif + return true; +} + +namespace { + +class InitUDPSocketParentCallback final : public Runnable +{ +public: + InitUDPSocketParentCallback(UDPSocketParent* aActor, + const nsACString& aFilter) + : mActor(aActor) + , mFilter(aFilter) + { + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + } + + NS_IMETHOD + Run() override + { + AssertIsInMainProcess(); + + IPC::Principal principal; + if (!mActor->Init(principal, mFilter)) { + MOZ_CRASH("UDPSocketCallback - failed init"); + } + return NS_OK; + } + +private: + ~InitUDPSocketParentCallback() {}; + + RefPtr<UDPSocketParent> mActor; + nsCString mFilter; +}; + +} // namespace + +auto +BackgroundParentImpl::AllocPUDPSocketParent(const OptionalPrincipalInfo& /* unused */, + const nsCString& /* unused */) + -> PUDPSocketParent* +{ + RefPtr<UDPSocketParent> p = new UDPSocketParent(this); + + return p.forget().take(); +} + +bool +BackgroundParentImpl::RecvPUDPSocketConstructor(PUDPSocketParent* aActor, + const OptionalPrincipalInfo& aOptionalPrincipal, + const nsCString& aFilter) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + if (aOptionalPrincipal.type() == OptionalPrincipalInfo::TPrincipalInfo) { + // Support for checking principals (for non-mtransport use) will be handled in + // bug 1167039 + return false; + } + // No principal - This must be from mtransport (WebRTC/ICE) - We'd want + // to DispatchToMainThread() here, but if we do we must block RecvBind() + // until Init() gets run. Since we don't have a principal, and we verify + // we have a filter, we can safely skip the Dispatch and just invoke Init() + // to install the filter. + + // For mtransport, this will always be "stun", which doesn't allow outbound + // packets if they aren't STUN packets until a STUN response is seen. + if (!aFilter.EqualsASCII(NS_NETWORK_SOCKET_FILTER_HANDLER_STUN_SUFFIX)) { + return false; + } + + IPC::Principal principal; + if (!static_cast<UDPSocketParent*>(aActor)->Init(principal, aFilter)) { + MOZ_CRASH("UDPSocketCallback - failed init"); + } + + return true; +} + +bool +BackgroundParentImpl::DeallocPUDPSocketParent(PUDPSocketParent* actor) +{ + UDPSocketParent* p = static_cast<UDPSocketParent*>(actor); + p->Release(); + return true; +} + +mozilla::dom::PBroadcastChannelParent* +BackgroundParentImpl::AllocPBroadcastChannelParent( + const PrincipalInfo& aPrincipalInfo, + const nsCString& aOrigin, + const nsString& aChannel) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + nsString originChannelKey; + + // The format of originChannelKey is: + // <channelName>|<origin+OriginAttributes> + + originChannelKey.Assign(aChannel); + + originChannelKey.AppendLiteral("|"); + + originChannelKey.Append(NS_ConvertUTF8toUTF16(aOrigin)); + + return new BroadcastChannelParent(originChannelKey); +} + +namespace { + +struct MOZ_STACK_CLASS NullifyContentParentRAII +{ + explicit NullifyContentParentRAII(RefPtr<ContentParent>& aContentParent) + : mContentParent(aContentParent) + {} + + ~NullifyContentParentRAII() + { + mContentParent = nullptr; + } + + RefPtr<ContentParent>& mContentParent; +}; + +class CheckPrincipalRunnable final : public Runnable +{ +public: + CheckPrincipalRunnable(already_AddRefed<ContentParent> aParent, + const PrincipalInfo& aPrincipalInfo, + const nsCString& aOrigin) + : mContentParent(aParent) + , mPrincipalInfo(aPrincipalInfo) + , mOrigin(aOrigin) + { + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + MOZ_ASSERT(mContentParent); + } + + NS_IMETHOD Run() override + { + MOZ_ASSERT(NS_IsMainThread()); + + NullifyContentParentRAII raii(mContentParent); + + nsCOMPtr<nsIPrincipal> principal = PrincipalInfoToPrincipal(mPrincipalInfo); + AssertAppPrincipal(mContentParent, principal); + + if (principal->GetIsNullPrincipal()) { + mContentParent->KillHard("BroadcastChannel killed: no null principal."); + return NS_OK; + } + + nsAutoCString origin; + nsresult rv = principal->GetOrigin(origin); + if (NS_FAILED(rv)) { + mContentParent->KillHard("BroadcastChannel killed: principal::GetOrigin failed."); + return NS_OK; + } + + if (NS_WARN_IF(!mOrigin.Equals(origin))) { + mContentParent->KillHard("BroadcastChannel killed: origins do not match."); + return NS_OK; + } + + return NS_OK; + } + +private: + RefPtr<ContentParent> mContentParent; + PrincipalInfo mPrincipalInfo; + nsCString mOrigin; +}; + +} // namespace + +bool +BackgroundParentImpl::RecvPBroadcastChannelConstructor( + PBroadcastChannelParent* actor, + const PrincipalInfo& aPrincipalInfo, + const nsCString& aOrigin, + const nsString& aChannel) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + RefPtr<ContentParent> parent = BackgroundParent::GetContentParent(this); + + // If the ContentParent is null we are dealing with a same-process actor. + if (!parent) { + MOZ_ASSERT(aPrincipalInfo.type() != PrincipalInfo::TNullPrincipalInfo); + return true; + } + + RefPtr<CheckPrincipalRunnable> runnable = + new CheckPrincipalRunnable(parent.forget(), aPrincipalInfo, aOrigin); + MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(runnable)); + + return true; +} + +bool +BackgroundParentImpl::DeallocPBroadcastChannelParent( + PBroadcastChannelParent* aActor) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + MOZ_ASSERT(aActor); + + delete static_cast<BroadcastChannelParent*>(aActor); + return true; +} + +mozilla::dom::PServiceWorkerManagerParent* +BackgroundParentImpl::AllocPServiceWorkerManagerParent() +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + RefPtr<dom::workers::ServiceWorkerManagerParent> agent = + new dom::workers::ServiceWorkerManagerParent(); + return agent.forget().take(); +} + +bool +BackgroundParentImpl::DeallocPServiceWorkerManagerParent( + PServiceWorkerManagerParent* aActor) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + MOZ_ASSERT(aActor); + + RefPtr<dom::workers::ServiceWorkerManagerParent> parent = + dont_AddRef(static_cast<dom::workers::ServiceWorkerManagerParent*>(aActor)); + MOZ_ASSERT(parent); + return true; +} + +bool +BackgroundParentImpl::RecvShutdownServiceWorkerRegistrar() +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + if (BackgroundParent::IsOtherProcessActor(this)) { + return false; + } + + RefPtr<dom::ServiceWorkerRegistrar> service = + dom::ServiceWorkerRegistrar::Get(); + MOZ_ASSERT(service); + + service->Shutdown(); + return true; +} + +PCacheStorageParent* +BackgroundParentImpl::AllocPCacheStorageParent(const Namespace& aNamespace, + const PrincipalInfo& aPrincipalInfo) +{ + return dom::cache::AllocPCacheStorageParent(this, aNamespace, aPrincipalInfo); +} + +bool +BackgroundParentImpl::DeallocPCacheStorageParent(PCacheStorageParent* aActor) +{ + dom::cache::DeallocPCacheStorageParent(aActor); + return true; +} + +PCacheParent* +BackgroundParentImpl::AllocPCacheParent() +{ + MOZ_CRASH("CacheParent actor must be provided to PBackground manager"); + return nullptr; +} + +bool +BackgroundParentImpl::DeallocPCacheParent(PCacheParent* aActor) +{ + dom::cache::DeallocPCacheParent(aActor); + return true; +} + +PCacheStreamControlParent* +BackgroundParentImpl::AllocPCacheStreamControlParent() +{ + MOZ_CRASH("CacheStreamControlParent actor must be provided to PBackground manager"); + return nullptr; +} + +bool +BackgroundParentImpl::DeallocPCacheStreamControlParent(PCacheStreamControlParent* aActor) +{ + dom::cache::DeallocPCacheStreamControlParent(aActor); + return true; +} + +PMessagePortParent* +BackgroundParentImpl::AllocPMessagePortParent(const nsID& aUUID, + const nsID& aDestinationUUID, + const uint32_t& aSequenceID) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + return new MessagePortParent(aUUID); +} + +bool +BackgroundParentImpl::RecvPMessagePortConstructor(PMessagePortParent* aActor, + const nsID& aUUID, + const nsID& aDestinationUUID, + const uint32_t& aSequenceID) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + MessagePortParent* mp = static_cast<MessagePortParent*>(aActor); + return mp->Entangle(aDestinationUUID, aSequenceID); +} + +bool +BackgroundParentImpl::DeallocPMessagePortParent(PMessagePortParent* aActor) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + MOZ_ASSERT(aActor); + + delete static_cast<MessagePortParent*>(aActor); + return true; +} + +bool +BackgroundParentImpl::RecvMessagePortForceClose(const nsID& aUUID, + const nsID& aDestinationUUID, + const uint32_t& aSequenceID) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + return MessagePortParent::ForceClose(aUUID, aDestinationUUID, aSequenceID); +} + +PAsmJSCacheEntryParent* +BackgroundParentImpl::AllocPAsmJSCacheEntryParent( + const dom::asmjscache::OpenMode& aOpenMode, + const dom::asmjscache::WriteParams& aWriteParams, + const PrincipalInfo& aPrincipalInfo) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + return + dom::asmjscache::AllocEntryParent(aOpenMode, aWriteParams, aPrincipalInfo); +} + +bool +BackgroundParentImpl::DeallocPAsmJSCacheEntryParent( + PAsmJSCacheEntryParent* aActor) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + dom::asmjscache::DeallocEntryParent(aActor); + return true; +} + +BackgroundParentImpl::PQuotaParent* +BackgroundParentImpl::AllocPQuotaParent() +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + return mozilla::dom::quota::AllocPQuotaParent(); +} + +bool +BackgroundParentImpl::DeallocPQuotaParent(PQuotaParent* aActor) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + MOZ_ASSERT(aActor); + + return mozilla::dom::quota::DeallocPQuotaParent(aActor); +} + +dom::PFileSystemRequestParent* +BackgroundParentImpl::AllocPFileSystemRequestParent( + const FileSystemParams& aParams) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + RefPtr<FileSystemRequestParent> result = new FileSystemRequestParent(); + + if (NS_WARN_IF(!result->Initialize(aParams))) { + return nullptr; + } + + return result.forget().take(); +} + +bool +BackgroundParentImpl::RecvPFileSystemRequestConstructor( + PFileSystemRequestParent* aActor, + const FileSystemParams& params) +{ + static_cast<FileSystemRequestParent*>(aActor)->Start(); + return true; +} + +bool +BackgroundParentImpl::DeallocPFileSystemRequestParent( + PFileSystemRequestParent* aDoomed) +{ + AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); + + RefPtr<FileSystemRequestParent> parent = + dont_AddRef(static_cast<FileSystemRequestParent*>(aDoomed)); + return true; +} + +// Gamepad API Background IPC +dom::PGamepadEventChannelParent* +BackgroundParentImpl::AllocPGamepadEventChannelParent() +{ +#ifdef MOZ_GAMEPAD + RefPtr<dom::GamepadEventChannelParent> parent = + new dom::GamepadEventChannelParent(); + + return parent.forget().take(); +#else + return nullptr; +#endif +} + +bool +BackgroundParentImpl::DeallocPGamepadEventChannelParent(dom::PGamepadEventChannelParent *aActor) +{ +#ifdef MOZ_GAMEPAD + MOZ_ASSERT(aActor); + RefPtr<dom::GamepadEventChannelParent> parent = + dont_AddRef(static_cast<dom::GamepadEventChannelParent*>(aActor)); +#endif + return true; +} + +dom::PGamepadTestChannelParent* +BackgroundParentImpl::AllocPGamepadTestChannelParent() +{ +#ifdef MOZ_GAMEPAD + RefPtr<dom::GamepadTestChannelParent> parent = + new dom::GamepadTestChannelParent(); + + return parent.forget().take(); +#else + return nullptr; +#endif +} + +bool +BackgroundParentImpl::DeallocPGamepadTestChannelParent(dom::PGamepadTestChannelParent *aActor) +{ +#ifdef MOZ_GAMEPAD + MOZ_ASSERT(aActor); + RefPtr<dom::GamepadTestChannelParent> parent = + dont_AddRef(static_cast<dom::GamepadTestChannelParent*>(aActor)); +#endif + return true; +} + +} // namespace ipc +} // namespace mozilla + +void +TestParent::ActorDestroy(ActorDestroyReason aWhy) +{ + mozilla::ipc::AssertIsInMainProcess(); + AssertIsOnBackgroundThread(); +} |