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

#ifndef PRemoteDecoder_h
#define PRemoteDecoder_h

#include "mozilla/Attributes.h"
#include "IPCMessageStart.h"
#include "mozilla/RefPtr.h"
#include "nsString.h"
#include "nsTArray.h"
#include "nsTHashtable.h"
#include "mozilla/MozPromise.h"
#include "mozilla/OperatorNewExtensions.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/ipc/ByteBuf.h"
#include "mozilla/ipc/FileDescriptor.h"
#include "mozilla/ipc/IPCForwards.h"
#include "mozilla/ipc/Shmem.h"

// Headers for typedefs
#include "MediaInfo.h"
#include "MediaResult.h"
#include "PlatformDecoderModule.h"
#include "mozilla/RemoteMediaData.h"
#include "mozilla/ipc/IPDLStructMember.h"
#include "mozilla/PMediaDecoderParams.h"
#include "mozilla/layers/LayersSurfaces.h"


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union DecodedOutputIPDL|
//
namespace mozilla {
class DecodedOutputIPDL final
{
public:
    enum Type {
        T__None,
        TArrayOfRemoteAudioData = 1,
        TArrayOfRemoteVideoData,
        T__Last = TArrayOfRemoteVideoData
    };

private:
    typedef ::mozilla::ArrayOfRemoteAudioData ArrayOfRemoteAudioData;
    typedef ::mozilla::ArrayOfRemoteVideoData ArrayOfRemoteVideoData;
    typedef RefPtr<ArrayOfRemoteAudioData> ArrayOfRemoteAudioData__tdef;
    typedef RefPtr<ArrayOfRemoteVideoData> ArrayOfRemoteVideoData__tdef;

    RefPtr<ArrayOfRemoteAudioData>*
    ptr_ArrayOfRemoteAudioData()
    {
        return (&(mVArrayOfRemoteAudioData));
    }
    const RefPtr<ArrayOfRemoteAudioData>*
    constptr_ArrayOfRemoteAudioData() const
    {
        return (&(mVArrayOfRemoteAudioData));
    }
    RefPtr<ArrayOfRemoteVideoData>*
    ptr_ArrayOfRemoteVideoData()
    {
        return (&(mVArrayOfRemoteVideoData));
    }
    const RefPtr<ArrayOfRemoteVideoData>*
    constptr_ArrayOfRemoteVideoData() const
    {
        return (&(mVArrayOfRemoteVideoData));
    }

    void
    MaybeDestroy();

    void
    AssertSanity() const
    {
        MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
        MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
    }
    void
    AssertSanity(Type aType) const
    {
        AssertSanity();
        MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
    }

public:
    MOZ_IMPLICIT DecodedOutputIPDL() :
        mType(T__None)
    {
    }

    MOZ_IMPLICIT DecodedOutputIPDL(ArrayOfRemoteAudioData* aOther);

    MOZ_IMPLICIT DecodedOutputIPDL(RefPtr<ArrayOfRemoteAudioData>&& aOther);

    MOZ_IMPLICIT DecodedOutputIPDL(ArrayOfRemoteVideoData* aOther);

    MOZ_IMPLICIT DecodedOutputIPDL(RefPtr<ArrayOfRemoteVideoData>&& aOther);

    MOZ_IMPLICIT DecodedOutputIPDL(const DecodedOutputIPDL& aOther);

    MOZ_IMPLICIT DecodedOutputIPDL(DecodedOutputIPDL&& aOther);

    ~DecodedOutputIPDL();

    Type
    type() const
    {
        return mType;
    }

    DecodedOutputIPDL&
    operator=(ArrayOfRemoteAudioData* aRhs);

    DecodedOutputIPDL&
    operator=(RefPtr<ArrayOfRemoteAudioData>&& aRhs);

    DecodedOutputIPDL&
    operator=(ArrayOfRemoteVideoData* aRhs);

    DecodedOutputIPDL&
    operator=(RefPtr<ArrayOfRemoteVideoData>&& aRhs);

    DecodedOutputIPDL&
    operator=(const DecodedOutputIPDL& aRhs);

    DecodedOutputIPDL&
    operator=(DecodedOutputIPDL&& aRhs);

    RefPtr<ArrayOfRemoteAudioData>&
    get_ArrayOfRemoteAudioData()
    {
        AssertSanity(TArrayOfRemoteAudioData);
        return (*(ptr_ArrayOfRemoteAudioData()));
    }
    ArrayOfRemoteAudioData*
    get_ArrayOfRemoteAudioData() const
    {
        AssertSanity(TArrayOfRemoteAudioData);
        return (*(constptr_ArrayOfRemoteAudioData()));
    }
    operator RefPtr<ArrayOfRemoteAudioData>&()
    {
        return get_ArrayOfRemoteAudioData();
    }
    operator ArrayOfRemoteAudioData*() const
    {
        return get_ArrayOfRemoteAudioData();
    }

    RefPtr<ArrayOfRemoteVideoData>&
    get_ArrayOfRemoteVideoData()
    {
        AssertSanity(TArrayOfRemoteVideoData);
        return (*(ptr_ArrayOfRemoteVideoData()));
    }
    ArrayOfRemoteVideoData*
    get_ArrayOfRemoteVideoData() const
    {
        AssertSanity(TArrayOfRemoteVideoData);
        return (*(constptr_ArrayOfRemoteVideoData()));
    }
    operator RefPtr<ArrayOfRemoteVideoData>&()
    {
        return get_ArrayOfRemoteVideoData();
    }
    operator ArrayOfRemoteVideoData*() const
    {
        return get_ArrayOfRemoteVideoData();
    }

private:
    union {
        RefPtr<ArrayOfRemoteAudioData> mVArrayOfRemoteAudioData;
        RefPtr<ArrayOfRemoteVideoData> mVArrayOfRemoteVideoData;
    };
    Type mType;
};
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct DecodePropertyIPDL|
//
namespace mozilla {
class DecodePropertyIPDL final
{
private:
    typedef ::mozilla::MediaDataDecoder::PropertyName PropertyName;
    typedef ::mozilla::MediaDataDecoder::PropertyValue PropertyValue;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    DecodePropertyIPDL() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT DecodePropertyIPDL(
            const PropertyName& _name,
            const PropertyValue& _value) :
        name_(_name),
        value_(_value)
    {
    }

    MOZ_IMPLICIT DecodePropertyIPDL(
            PropertyName&& _name,
            PropertyValue&& _value) :
        name_(std::move(_name)),
        value_(std::move(_value))
    {
    }

    PropertyName&
    name()
    {
        return name_;
    }
    const PropertyName&
    name() const
    {
        return name_;
    }

    PropertyValue&
    value()
    {
        return value_;
    }
    const PropertyValue&
    value() const
    {
        return value_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<PropertyName> name_;
    ::mozilla::ipc::IPDLStructMember<PropertyValue> value_;
};
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct InitCompletionIPDL|
//
namespace mozilla {
class InitCompletionIPDL final
{
private:
    typedef ::mozilla::TrackInfo::TrackType TrackType;
    typedef ::nsCString nsCString;
    typedef ::mozilla::MediaDataDecoder::ConversionRequired ConversionRequired;
    typedef ::mozilla::DecodePropertyIPDL DecodePropertyIPDL;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    InitCompletionIPDL() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT InitCompletionIPDL(
            const TrackType& _type,
            const nsCString& _decoderDescription,
            const nsCString& _decoderProcessName,
            const nsCString& _decoderCodecName,
            const bool& _hardware,
            const nsCString& _hardwareReason,
            const ConversionRequired& _conversion,
            const bool& _shouldDecoderAlwaysBeRecycled,
            const nsTArray<DecodePropertyIPDL>& _decodeProperties) :
        type_(_type),
        decoderDescription_(_decoderDescription),
        decoderProcessName_(_decoderProcessName),
        decoderCodecName_(_decoderCodecName),
        hardware_(_hardware),
        hardwareReason_(_hardwareReason),
        conversion_(_conversion),
        shouldDecoderAlwaysBeRecycled_(_shouldDecoderAlwaysBeRecycled),
        decodeProperties_(_decodeProperties)
    {
    }

    MOZ_IMPLICIT InitCompletionIPDL(
            TrackType&& _type,
            nsCString&& _decoderDescription,
            nsCString&& _decoderProcessName,
            nsCString&& _decoderCodecName,
            bool&& _hardware,
            nsCString&& _hardwareReason,
            ConversionRequired&& _conversion,
            bool&& _shouldDecoderAlwaysBeRecycled,
            nsTArray<DecodePropertyIPDL>&& _decodeProperties) :
        type_(std::move(_type)),
        decoderDescription_(std::move(_decoderDescription)),
        decoderProcessName_(std::move(_decoderProcessName)),
        decoderCodecName_(std::move(_decoderCodecName)),
        hardware_(std::move(_hardware)),
        hardwareReason_(std::move(_hardwareReason)),
        conversion_(std::move(_conversion)),
        shouldDecoderAlwaysBeRecycled_(std::move(_shouldDecoderAlwaysBeRecycled)),
        decodeProperties_(std::move(_decodeProperties))
    {
    }

    TrackType&
    type()
    {
        return type_;
    }
    const TrackType&
    type() const
    {
        return type_;
    }

    nsCString&
    decoderDescription()
    {
        return decoderDescription_;
    }
    const nsCString&
    decoderDescription() const
    {
        return decoderDescription_;
    }

    nsCString&
    decoderProcessName()
    {
        return decoderProcessName_;
    }
    const nsCString&
    decoderProcessName() const
    {
        return decoderProcessName_;
    }

    nsCString&
    decoderCodecName()
    {
        return decoderCodecName_;
    }
    const nsCString&
    decoderCodecName() const
    {
        return decoderCodecName_;
    }

    bool&
    hardware()
    {
        return hardware_;
    }
    const bool&
    hardware() const
    {
        return hardware_;
    }

    nsCString&
    hardwareReason()
    {
        return hardwareReason_;
    }
    const nsCString&
    hardwareReason() const
    {
        return hardwareReason_;
    }

    ConversionRequired&
    conversion()
    {
        return conversion_;
    }
    const ConversionRequired&
    conversion() const
    {
        return conversion_;
    }

    bool&
    shouldDecoderAlwaysBeRecycled()
    {
        return shouldDecoderAlwaysBeRecycled_;
    }
    const bool&
    shouldDecoderAlwaysBeRecycled() const
    {
        return shouldDecoderAlwaysBeRecycled_;
    }

    nsTArray<DecodePropertyIPDL>&
    decodeProperties()
    {
        return decodeProperties_;
    }
    const nsTArray<DecodePropertyIPDL>&
    decodeProperties() const
    {
        return decodeProperties_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<TrackType> type_;
    ::mozilla::ipc::IPDLStructMember<nsCString> decoderDescription_;
    ::mozilla::ipc::IPDLStructMember<nsCString> decoderProcessName_;
    ::mozilla::ipc::IPDLStructMember<nsCString> decoderCodecName_;
    ::mozilla::ipc::IPDLStructMember<bool> hardware_;
    ::mozilla::ipc::IPDLStructMember<nsCString> hardwareReason_;
    ::mozilla::ipc::IPDLStructMember<ConversionRequired> conversion_;
    ::mozilla::ipc::IPDLStructMember<bool> shouldDecoderAlwaysBeRecycled_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<DecodePropertyIPDL>> decodeProperties_;
};
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union InitResultIPDL|
//
namespace mozilla {
class InitResultIPDL final
{
public:
    enum Type {
        T__None,
        TMediaResult = 1,
        TInitCompletionIPDL,
        T__Last = TInitCompletionIPDL
    };

private:
    typedef ::mozilla::MediaResult MediaResult;
    typedef ::mozilla::InitCompletionIPDL InitCompletionIPDL;
    typedef MediaResult MediaResult__tdef;
    typedef InitCompletionIPDL InitCompletionIPDL__tdef;

    MediaResult*
    ptr_MediaResult()
    {
        return (&(mVMediaResult));
    }
    const MediaResult*
    constptr_MediaResult() const
    {
        return (&(mVMediaResult));
    }
    InitCompletionIPDL*
    ptr_InitCompletionIPDL()
    {
        return (&(mVInitCompletionIPDL));
    }
    const InitCompletionIPDL*
    constptr_InitCompletionIPDL() const
    {
        return (&(mVInitCompletionIPDL));
    }

    void
    MaybeDestroy();

    void
    AssertSanity() const
    {
        MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
        MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
    }
    void
    AssertSanity(Type aType) const
    {
        AssertSanity();
        MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
    }

public:
    MOZ_IMPLICIT InitResultIPDL() :
        mType(T__None)
    {
    }

    MOZ_IMPLICIT InitResultIPDL(const MediaResult& aOther);

    MOZ_IMPLICIT InitResultIPDL(MediaResult&& aOther);

    MOZ_IMPLICIT InitResultIPDL(const InitCompletionIPDL& aOther);

    MOZ_IMPLICIT InitResultIPDL(InitCompletionIPDL&& aOther);

    MOZ_IMPLICIT InitResultIPDL(const InitResultIPDL& aOther);

    MOZ_IMPLICIT InitResultIPDL(InitResultIPDL&& aOther);

    ~InitResultIPDL();

    Type
    type() const
    {
        return mType;
    }

    InitResultIPDL&
    operator=(const MediaResult& aRhs);

    InitResultIPDL&
    operator=(MediaResult&& aRhs);

    InitResultIPDL&
    operator=(const InitCompletionIPDL& aRhs);

    InitResultIPDL&
    operator=(InitCompletionIPDL&& aRhs);

    InitResultIPDL&
    operator=(const InitResultIPDL& aRhs);

    InitResultIPDL&
    operator=(InitResultIPDL&& aRhs);

    MediaResult&
    get_MediaResult()
    {
        AssertSanity(TMediaResult);
        return (*(ptr_MediaResult()));
    }
    const MediaResult&
    get_MediaResult() const
    {
        AssertSanity(TMediaResult);
        return (*(constptr_MediaResult()));
    }
    operator MediaResult&()
    {
        return get_MediaResult();
    }
    operator const MediaResult&() const
    {
        return get_MediaResult();
    }

    InitCompletionIPDL&
    get_InitCompletionIPDL()
    {
        AssertSanity(TInitCompletionIPDL);
        return (*(ptr_InitCompletionIPDL()));
    }
    const InitCompletionIPDL&
    get_InitCompletionIPDL() const
    {
        AssertSanity(TInitCompletionIPDL);
        return (*(constptr_InitCompletionIPDL()));
    }
    operator InitCompletionIPDL&()
    {
        return get_InitCompletionIPDL();
    }
    operator const InitCompletionIPDL&() const
    {
        return get_InitCompletionIPDL();
    }

private:
    union {
        MediaResult mVMediaResult;
        InitCompletionIPDL mVInitCompletionIPDL;
    };
    Type mType;
};
} // namespace mozilla

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


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union DecodeResultIPDL|
//
namespace mozilla {
class DecodeResultIPDL final
{
public:
    enum Type {
        T__None,
        TMediaResult = 1,
        TDecodedOutputIPDL,
        T__Last = TDecodedOutputIPDL
    };

private:
    typedef ::mozilla::MediaResult MediaResult;
    typedef ::mozilla::DecodedOutputIPDL DecodedOutputIPDL;
    typedef MediaResult MediaResult__tdef;
    typedef DecodedOutputIPDL DecodedOutputIPDL__tdef;

    MediaResult*
    ptr_MediaResult()
    {
        return (&(mVMediaResult));
    }
    const MediaResult*
    constptr_MediaResult() const
    {
        return (&(mVMediaResult));
    }
    DecodedOutputIPDL*
    ptr_DecodedOutputIPDL()
    {
        return (&(mVDecodedOutputIPDL));
    }
    const DecodedOutputIPDL*
    constptr_DecodedOutputIPDL() const
    {
        return (&(mVDecodedOutputIPDL));
    }

    void
    MaybeDestroy();

    void
    AssertSanity() const
    {
        MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
        MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
    }
    void
    AssertSanity(Type aType) const
    {
        AssertSanity();
        MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
    }

public:
    MOZ_IMPLICIT DecodeResultIPDL() :
        mType(T__None)
    {
    }

    MOZ_IMPLICIT DecodeResultIPDL(const MediaResult& aOther);

    MOZ_IMPLICIT DecodeResultIPDL(MediaResult&& aOther);

    MOZ_IMPLICIT DecodeResultIPDL(const DecodedOutputIPDL& aOther);

    MOZ_IMPLICIT DecodeResultIPDL(DecodedOutputIPDL&& aOther);

    MOZ_IMPLICIT DecodeResultIPDL(const DecodeResultIPDL& aOther);

    MOZ_IMPLICIT DecodeResultIPDL(DecodeResultIPDL&& aOther);

    ~DecodeResultIPDL();

    Type
    type() const
    {
        return mType;
    }

    DecodeResultIPDL&
    operator=(const MediaResult& aRhs);

    DecodeResultIPDL&
    operator=(MediaResult&& aRhs);

    DecodeResultIPDL&
    operator=(const DecodedOutputIPDL& aRhs);

    DecodeResultIPDL&
    operator=(DecodedOutputIPDL&& aRhs);

    DecodeResultIPDL&
    operator=(const DecodeResultIPDL& aRhs);

    DecodeResultIPDL&
    operator=(DecodeResultIPDL&& aRhs);

    MediaResult&
    get_MediaResult()
    {
        AssertSanity(TMediaResult);
        return (*(ptr_MediaResult()));
    }
    const MediaResult&
    get_MediaResult() const
    {
        AssertSanity(TMediaResult);
        return (*(constptr_MediaResult()));
    }
    operator MediaResult&()
    {
        return get_MediaResult();
    }
    operator const MediaResult&() const
    {
        return get_MediaResult();
    }

    DecodedOutputIPDL&
    get_DecodedOutputIPDL()
    {
        AssertSanity(TDecodedOutputIPDL);
        return (*(ptr_DecodedOutputIPDL()));
    }
    const DecodedOutputIPDL&
    get_DecodedOutputIPDL() const
    {
        AssertSanity(TDecodedOutputIPDL);
        return (*(constptr_DecodedOutputIPDL()));
    }
    operator DecodedOutputIPDL&()
    {
        return get_DecodedOutputIPDL();
    }
    operator const DecodedOutputIPDL&() const
    {
        return get_DecodedOutputIPDL();
    }

private:
    union {
        MediaResult mVMediaResult;
        DecodedOutputIPDL mVDecodedOutputIPDL;
    };
    Type mType;
};
} // namespace mozilla

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

namespace mozilla {
class PRemoteDecoderParent;
} // namespace mozilla
namespace mozilla {
class PRemoteDecoderChild;
} // namespace mozilla

//-----------------------------------------------------------------------------
// Code common to PRemoteDecoderChild and PRemoteDecoderParent
//
namespace mozilla {
namespace PRemoteDecoder {

nsresult
CreateEndpoints(
        mozilla::ipc::EndpointProcInfo aParentDestInfo,
        mozilla::ipc::EndpointProcInfo aChildDestInfo,
        mozilla::ipc::Endpoint<::mozilla::PRemoteDecoderParent>* aParent,
        mozilla::ipc::Endpoint<::mozilla::PRemoteDecoderChild>* aChild);

enum MessageType {
    PRemoteDecoderStart = PRemoteDecoderMsgStart << 16,
    Msg_Construct__ID,
    Reply_Construct__ID,
    Msg_Init__ID,
    Reply_Init__ID,
    Msg_Decode__ID,
    Reply_Decode__ID,
    Msg_Flush__ID,
    Reply_Flush__ID,
    Msg_Drain__ID,
    Reply_Drain__ID,
    Msg_Shutdown__ID,
    Reply_Shutdown__ID,
    Msg_SetSeekThreshold__ID,
    Msg___delete____ID,
    Reply___delete____ID,
    PRemoteDecoderEnd
};

mozilla::UniquePtr<IPC::Message>
Msg_Construct(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_Construct(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_Init(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_Init(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_Decode(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_Decode(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_Flush(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_Flush(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_Drain(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_Drain(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_Shutdown(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_Shutdown(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_SetSeekThreshold(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg___delete__(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply___delete__(IPC::Message::routeid_t routingId);



} // namespace PRemoteDecoder
} // namespace mozilla

#endif // ifndef PRemoteDecoder_h
