//
// Automatically generated by ipdlc.
// Edit at your own risk
//

#ifndef PQuotaChild_h
#define PQuotaChild_h

#include "mozilla/dom/quota/PQuota.h"
#ifdef DEBUG
#include "prenv.h"
#endif  // DEBUG

#include "mozilla/Tainting.h"
#include "mozilla/ipc/MessageChannel.h"
#include "mozilla/ipc/ProtocolUtils.h"
// Headers for things that cannot be forward declared
#include "mozilla/OriginAttributes.h"
#include "mozilla/dom/IntegrityPolicy.h"
#include "mozilla/dom/ipc/IdType.h"
#include "mozilla/dom/quota/Client.h"
#include "mozilla/dom/quota/CommonMetadataArray.h"
#include "mozilla/dom/quota/PersistenceType.h"
#include "mozilla/dom/quota/UsageInfo.h"
#include "mozilla/ipc/BackgroundUtils.h"
#include "nsIContentSecurityPolicy.h"

namespace mozilla {
namespace ipc {
class PBackgroundChild;
} // namespace ipc
} // namespace mozilla
namespace mozilla {
namespace ipc {
class PBackgroundParent;
} // namespace ipc
} // namespace mozilla

namespace mozilla {
namespace dom {
namespace quota {
class PQuotaRequestChild;
} // namespace quota
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
namespace quota {
class PQuotaRequestParent;
} // namespace quota
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
namespace quota {
class PQuotaUsageRequestChild;
} // namespace quota
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
namespace quota {
class PQuotaUsageRequestParent;
} // namespace quota
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
namespace quota {
class PQuotaRequestChild;
} // namespace quota
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
namespace quota {
class PQuotaUsageRequestChild;
} // namespace quota
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace ipc {
class PBackgroundChild;
} // namespace ipc
} // namespace mozilla

namespace mozilla {
struct void_t;
} // namespace mozilla

namespace mozilla {
namespace dom {
namespace quota {


class PQuotaChild :
    public mozilla::ipc::IRefCountedProtocol
{
private:
    friend class ::mozilla::dom::quota::PQuotaRequestChild;
    friend class ::mozilla::dom::quota::PQuotaUsageRequestChild;
    friend class ::mozilla::ipc::PBackgroundChild;
public:
    static constexpr ::mozilla::ipc::ProtocolId kProtocolId = PQuotaMsgStart;
protected:
    typedef mozilla::ipc::ActorId ActorId;
    typedef ::mozilla::ipc::BoolResponse BoolResponse;
    typedef ::mozilla::ipc::ByteBuf ByteBuf;
    typedef ::mozilla::ipc::CSPInfo CSPInfo;
    typedef ::mozilla::ipc::CStringArrayResponse CStringArrayResponse;
    typedef ::mozilla::dom::quota::ClearResetOriginParams ClearResetOriginParams;
    typedef ::mozilla::dom::ContentParentId ContentParentId;
    typedef ::mozilla::ipc::ContentPrincipalInfo ContentPrincipalInfo;
    typedef ::mozilla::ipc::ContentSecurityPolicy ContentSecurityPolicy;
    typedef ::mozilla::dom::IntegrityPolicy::Destinations Destinations;
    template<class FooSide> using Endpoint = mozilla::ipc::Endpoint<FooSide>;
    typedef ::mozilla::dom::quota::EstimateParams EstimateParams;
    typedef ::mozilla::ipc::ExpandedPrincipalInfo ExpandedPrincipalInfo;
    typedef ::mozilla::ipc::FileDescriptor FileDescriptor;
    typedef ::mozilla::dom::quota::GetFullOriginMetadataParams GetFullOriginMetadataParams;
    typedef ::mozilla::ipc::IntegrityPolicyArgs IntegrityPolicyArgs;
    typedef ::mozilla::ipc::IntegrityPolicyEntry IntegrityPolicyEntry;
    template<class FooSide> using ManagedEndpoint = mozilla::ipc::ManagedEndpoint<FooSide>;
    typedef ::mozilla::ipc::NullPrincipalInfo NullPrincipalInfo;
    typedef ::mozilla::OriginAttributes OriginAttributes;
    typedef ::mozilla::OriginAttributesPattern OriginAttributesPattern;
    typedef ::mozilla::dom::quota::OriginUsageMetadataArray OriginUsageMetadataArray;
    typedef ::mozilla::dom::quota::OriginUsageMetadataArrayResponse OriginUsageMetadataArrayResponse;
    typedef ::mozilla::ipc::PBackgroundChild PBackgroundChild;
    typedef ::mozilla::ipc::PBackgroundParent PBackgroundParent;
    typedef ::mozilla::dom::quota::PQuotaRequestChild PQuotaRequestChild;
    typedef ::mozilla::dom::quota::PQuotaRequestParent PQuotaRequestParent;
    typedef ::mozilla::dom::quota::PQuotaUsageRequestChild PQuotaUsageRequestChild;
    typedef ::mozilla::dom::quota::PQuotaUsageRequestParent PQuotaUsageRequestParent;
    typedef ::mozilla::dom::quota::PersistParams PersistParams;
    typedef ::mozilla::dom::quota::PersistedParams PersistedParams;
    typedef ::mozilla::dom::quota::PersistenceType PersistenceType;
    typedef ::mozilla::ipc::PolicyContainerArgs PolicyContainerArgs;
    typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
    typedef base::ProcessId ProcessId;
    typedef mozilla::ipc::ProtocolId ProtocolId;
    typedef ::mozilla::dom::quota::RequestParams RequestParams;
    typedef ::nsIContentSecurityPolicy::RequireTrustedTypesForDirectiveState RequireTrustedTypesForDirectiveState;
    typedef mozilla::ipc::ResponseRejectReason ResponseRejectReason;
    typedef ::mozilla::ipc::Shmem Shmem;
    typedef ::mozilla::dom::IntegrityPolicy::Sources Sources;
    typedef ::mozilla::dom::quota::StorageNameParams StorageNameParams;
    typedef ::mozilla::ipc::SystemPrincipalInfo SystemPrincipalInfo;
    typedef ::mozilla::dom::quota::Client::Type Type;
    typedef ::mozilla::ipc::UInt64Response UInt64Response;
    template<class T> using UniquePtr = mozilla::UniquePtr<T>;
    typedef ::mozilla::dom::quota::UsageInfo UsageInfo;
    typedef ::mozilla::dom::quota::UsageInfoResponse UsageInfoResponse;
    typedef ::mozilla::ipc::WebTransportHash WebTransportHash;
    typedef ::int16_t int16_t;
    typedef ::int32_t int32_t;
    typedef ::int64_t int64_t;
    typedef ::int8_t int8_t;
    typedef ::intptr_t intptr_t;
    typedef ::nsCString nsCString;
    typedef ::nsString nsString;
    typedef ::nsresult nsresult;
    typedef ::uint16_t uint16_t;
    typedef ::uint32_t uint32_t;
    typedef ::uint64_t uint64_t;
    typedef ::uint8_t uint8_t;
    typedef ::uintptr_t uintptr_t;
    typedef ::mozilla::void_t void_t;

public:
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> StorageInitializedPromise;
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> PersistentStorageInitializedPromise;
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> TemporaryStorageInitializedPromise;
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> TemporaryGroupInitializedPromise;
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> PersistentOriginInitializedPromise;
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> TemporaryOriginInitializedPromise;
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> InitializeStoragePromise;
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> InitializePersistentStoragePromise;
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> InitializeAllTemporaryOriginsPromise;
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> InitializeTemporaryGroupPromise;
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> InitializePersistentOriginPromise;
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> InitializeTemporaryOriginPromise;
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> InitializePersistentClientPromise;
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> InitializeTemporaryClientPromise;
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> InitializeTemporaryStoragePromise;
    typedef MozPromise<OriginUsageMetadataArrayResponse, ResponseRejectReason, true> GetUsagePromise;
    typedef MozPromise<UsageInfoResponse, ResponseRejectReason, true> GetOriginUsagePromise;
    typedef MozPromise<UInt64Response, ResponseRejectReason, true> GetCachedOriginUsagePromise;
    typedef MozPromise<CStringArrayResponse, ResponseRejectReason, true> ListOriginsPromise;
    typedef MozPromise<CStringArrayResponse, ResponseRejectReason, true> ListCachedOriginsPromise;
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> ClearStoragesForOriginPromise;
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> ClearStoragesForClientPromise;
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> ClearStoragesForOriginPrefixPromise;
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> ClearStoragesForOriginAttributesPatternPromise;
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> ClearStoragesForPrivateBrowsingPromise;
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> ClearStoragePromise;
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> ShutdownStoragesForOriginPromise;
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> ShutdownStoragesForClientPromise;
    typedef MozPromise<BoolResponse, ResponseRejectReason, true> ShutdownStoragePromise;

protected:
    virtual PQuotaRequestChild*
    AllocPQuotaRequestChild(const RequestParams& params) = 0;
    virtual bool
    DeallocPQuotaRequestChild(PQuotaRequestChild* aActor) = 0;
public:
    typedef mozilla::ipc::IProtocol IProtocol;
    typedef IPC::Message Message;
    typedef base::ProcessHandle ProcessHandle;
    typedef mozilla::ipc::MessageChannel MessageChannel;

public:
    MOZ_IMPLICIT PQuotaChild();

    virtual ~PQuotaChild();

protected:
    void
    ActorAlloc() final;
    void
    ActorDealloc() final;
public:
    ::base::ProcessId
    OtherPid() const;
    ::GeckoChildID
    OtherChildID() const;
    ::mozilla::ipc::EndpointProcInfo
    OtherEndpointProcInfo() const;

    PBackgroundChild*
    Manager() const;

    void
    ManagedPQuotaRequestChild(nsTArray<PQuotaRequestChild*>& aArr) const;
    const ManagedContainer<PQuotaRequestChild>&
    ManagedPQuotaRequestChild() const;

    void
    ManagedPQuotaUsageRequestChild(nsTArray<PQuotaUsageRequestChild*>& aArr) const;
    const ManagedContainer<PQuotaUsageRequestChild>&
    ManagedPQuotaUsageRequestChild() const;

    mozilla::Span<mozilla::ipc::ProtocolId const>
    ManagedProtocolIds() const final;

    UntypedManagedContainer*
    GetManagedActors(mozilla::ipc::ProtocolId aProtocol) final;

    void
    RejectPendingResponses(ResponseRejectReason aReason) final;

    ManagedEndpoint<PQuotaRequestParent>
    OpenPQuotaRequestEndpoint(PQuotaRequestChild* aActor);
    bool
    BindPQuotaRequestEndpoint(
            ManagedEndpoint<PQuotaRequestChild> aEndpoint,
            PQuotaRequestChild* aActor);

    ManagedEndpoint<PQuotaUsageRequestParent>
    OpenPQuotaUsageRequestEndpoint(PQuotaUsageRequestChild* aActor);
    bool
    BindPQuotaUsageRequestEndpoint(
            ManagedEndpoint<PQuotaUsageRequestChild> aEndpoint,
            PQuotaUsageRequestChild* aActor);

    static bool
    Send__delete__(PQuotaChild* actor);

    PQuotaRequestChild*
    SendPQuotaRequestConstructor(const RequestParams& params);

    PQuotaRequestChild*
    SendPQuotaRequestConstructor(
            PQuotaRequestChild* actor,
            const RequestParams& params);

    void
    SendStorageInitialized(
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<StorageInitializedPromise>
    SendStorageInitialized();

    void
    SendPersistentStorageInitialized(
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<PersistentStorageInitializedPromise>
    SendPersistentStorageInitialized();

    void
    SendTemporaryStorageInitialized(
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<TemporaryStorageInitializedPromise>
    SendTemporaryStorageInitialized();

    void
    SendTemporaryGroupInitialized(
            const PrincipalInfo& principalInfo,
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<TemporaryGroupInitializedPromise>
    SendTemporaryGroupInitialized(const PrincipalInfo& principalInfo);

    void
    SendPersistentOriginInitialized(
            const PrincipalInfo& principalInfo,
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<PersistentOriginInitializedPromise>
    SendPersistentOriginInitialized(const PrincipalInfo& principalInfo);

    void
    SendTemporaryOriginInitialized(
            const PersistenceType& persistenceType,
            const PrincipalInfo& principalInfo,
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<TemporaryOriginInitializedPromise>
    SendTemporaryOriginInitialized(
            const PersistenceType& persistenceType,
            const PrincipalInfo& principalInfo);

    void
    SendInitializeStorage(
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<InitializeStoragePromise>
    SendInitializeStorage();

    void
    SendInitializePersistentStorage(
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<InitializePersistentStoragePromise>
    SendInitializePersistentStorage();

    void
    SendInitializeAllTemporaryOrigins(
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<InitializeAllTemporaryOriginsPromise>
    SendInitializeAllTemporaryOrigins();

    void
    SendInitializeTemporaryGroup(
            const PrincipalInfo& principalInfo,
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<InitializeTemporaryGroupPromise>
    SendInitializeTemporaryGroup(const PrincipalInfo& principalInfo);

    void
    SendInitializePersistentOrigin(
            const PrincipalInfo& principalInfo,
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<InitializePersistentOriginPromise>
    SendInitializePersistentOrigin(const PrincipalInfo& principalInfo);

    void
    SendInitializeTemporaryOrigin(
            const PersistenceType& persistenceType,
            const PrincipalInfo& principalInfo,
            const bool& createIfNonExistent,
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<InitializeTemporaryOriginPromise>
    SendInitializeTemporaryOrigin(
            const PersistenceType& persistenceType,
            const PrincipalInfo& principalInfo,
            const bool& createIfNonExistent);

    void
    SendInitializePersistentClient(
            const PrincipalInfo& principalInfo,
            const Type& clientType,
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<InitializePersistentClientPromise>
    SendInitializePersistentClient(
            const PrincipalInfo& principalInfo,
            const Type& clientType);

    void
    SendInitializeTemporaryClient(
            const PersistenceType& persistenceType,
            const PrincipalInfo& principalInfo,
            const Type& clientType,
            const bool& createIfNonExistent,
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<InitializeTemporaryClientPromise>
    SendInitializeTemporaryClient(
            const PersistenceType& persistenceType,
            const PrincipalInfo& principalInfo,
            const Type& clientType,
            const bool& createIfNonExistent);

    void
    SendInitializeTemporaryStorage(
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<InitializeTemporaryStoragePromise>
    SendInitializeTemporaryStorage();

    void
    SendGetUsage(
            const bool& getAll,
            ManagedEndpoint<::mozilla::dom::quota::PQuotaUsageRequestParent>&& parentEndpoint,
            mozilla::ipc::ResolveCallback<OriginUsageMetadataArrayResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<GetUsagePromise>
    SendGetUsage(
            const bool& getAll,
            ManagedEndpoint<::mozilla::dom::quota::PQuotaUsageRequestParent>&& parentEndpoint);

    void
    SendGetOriginUsage(
            const PrincipalInfo& principalInfo,
            ManagedEndpoint<::mozilla::dom::quota::PQuotaUsageRequestParent>&& parentEndpoint,
            mozilla::ipc::ResolveCallback<UsageInfoResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<GetOriginUsagePromise>
    SendGetOriginUsage(
            const PrincipalInfo& principalInfo,
            ManagedEndpoint<::mozilla::dom::quota::PQuotaUsageRequestParent>&& parentEndpoint);

    void
    SendGetCachedOriginUsage(
            const PrincipalInfo& principalInfo,
            mozilla::ipc::ResolveCallback<UInt64Response>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<GetCachedOriginUsagePromise>
    SendGetCachedOriginUsage(const PrincipalInfo& principalInfo);

    void
    SendListOrigins(
            mozilla::ipc::ResolveCallback<CStringArrayResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<ListOriginsPromise>
    SendListOrigins();

    void
    SendListCachedOrigins(
            mozilla::ipc::ResolveCallback<CStringArrayResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<ListCachedOriginsPromise>
    SendListCachedOrigins();

    void
    SendClearStoragesForOrigin(
            const mozilla::Maybe<PersistenceType>& persistenceType,
            const PrincipalInfo& principalInfo,
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<ClearStoragesForOriginPromise>
    SendClearStoragesForOrigin(
            const mozilla::Maybe<PersistenceType>& persistenceType,
            const PrincipalInfo& principalInfo);

    void
    SendClearStoragesForClient(
            const mozilla::Maybe<PersistenceType>& persistenceType,
            const PrincipalInfo& principalInfo,
            const Type& clientType,
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<ClearStoragesForClientPromise>
    SendClearStoragesForClient(
            const mozilla::Maybe<PersistenceType>& persistenceType,
            const PrincipalInfo& principalInfo,
            const Type& clientType);

    void
    SendClearStoragesForOriginPrefix(
            const mozilla::Maybe<PersistenceType>& persistenceType,
            const PrincipalInfo& principalInfo,
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<ClearStoragesForOriginPrefixPromise>
    SendClearStoragesForOriginPrefix(
            const mozilla::Maybe<PersistenceType>& persistenceType,
            const PrincipalInfo& principalInfo);

    void
    SendClearStoragesForOriginAttributesPattern(
            const OriginAttributesPattern& pattern,
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<ClearStoragesForOriginAttributesPatternPromise>
    SendClearStoragesForOriginAttributesPattern(const OriginAttributesPattern& pattern);

    void
    SendClearStoragesForPrivateBrowsing(
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<ClearStoragesForPrivateBrowsingPromise>
    SendClearStoragesForPrivateBrowsing();

    void
    SendClearStorage(
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<ClearStoragePromise>
    SendClearStorage();

    void
    SendShutdownStoragesForOrigin(
            const mozilla::Maybe<PersistenceType>& persistenceType,
            const PrincipalInfo& principalInfo,
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<ShutdownStoragesForOriginPromise>
    SendShutdownStoragesForOrigin(
            const mozilla::Maybe<PersistenceType>& persistenceType,
            const PrincipalInfo& principalInfo);

    void
    SendShutdownStoragesForClient(
            const mozilla::Maybe<PersistenceType>& persistenceType,
            const PrincipalInfo& principalInfo,
            const Type& clientType,
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<ShutdownStoragesForClientPromise>
    SendShutdownStoragesForClient(
            const mozilla::Maybe<PersistenceType>& persistenceType,
            const PrincipalInfo& principalInfo,
            const Type& clientType);

    void
    SendShutdownStorage(
            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,
            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<ShutdownStoragePromise>
    SendShutdownStorage();

    bool
    SendStartIdleMaintenance();

    bool
    SendStopIdleMaintenance();

    bool
    SendAbortOperationsForProcess(const ContentParentId& contentParentId);

    bool
    SendSetThumbnailPrivateIdentityId(const uint32_t& aThumbnailPrivateIdentityId);

    void
    DeallocManagee(
            mozilla::ipc::ProtocolId aProtocolId,
            IProtocol* aListener) override;

    Result
    OnMessageReceived(const Message& msg__) override;

    Result
    OnMessageReceived(
            const Message& msg__,
            UniquePtr<Message>& reply__) override;

private:
    mozilla::ipc::IPDLAsyncReturnsCallbacks mAsyncCallbacks;

    bool mAwaitingManagedEndpointBind = false;

    ManagedContainer<PQuotaRequestChild> mManagedPQuotaRequestChild;
    ManagedContainer<PQuotaUsageRequestChild> mManagedPQuotaUsageRequestChild;
};


} // namespace quota
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::quota::PQuotaChild*>
{
    typedef ::mozilla::dom::quota::PQuotaChild* paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC

#endif // ifndef PQuotaChild_h
