PQuotaChild.h - mozsearch

mozilla-central/__GENERATED__/ipc/ipdl/_ipdlheaders/mozilla/dom/quota/PQuotaChild.h (file symbol)

Enable keyboard shortcuts

Copy as Markdown

Other Tools

//

// 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/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"

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::ActorHandle ActorHandle;

    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;

    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::dom::quota::ListOriginsParams ListOriginsParams;

    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::PrincipalInfo PrincipalInfo;

    typedef base::ProcessId ProcessId;

    typedef mozilla::ipc::ProtocolId ProtocolId;

    typedef ::mozilla::dom::quota::RequestParams RequestParams;

    typedef mozilla::ipc::ResponseRejectReason ResponseRejectReason;

    typedef ::mozilla::ipc::Shmem Shmem;

    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> 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> 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;

    typedef mozilla::ipc::SharedMemory SharedMemory;

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

    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,

            mozilla::ipc::ResolveCallback<BoolResponse>&& aResolve,

            mozilla::ipc::RejectCallback&& aReject);

    RefPtr<InitializeTemporaryClientPromise>

    SendInitializeTemporaryClient(

            const PersistenceType& persistenceType,

            const PrincipalInfo& principalInfo,

            const Type& clientType);

    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

    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);

    void

    DeallocManagee(

            int32_t 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