Copy as Markdown
Other Tools
//
// 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 InitCompletionIPDL|
//
namespace mozilla {
class InitCompletionIPDL final
{
private:
typedef ::mozilla::TrackInfo::TrackType TrackType;
typedef ::nsCString nsCString;
typedef ::mozilla::MediaDataDecoder::ConversionRequired ConversionRequired;
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) :
type_(_type),
decoderDescription_(_decoderDescription),
decoderProcessName_(_decoderProcessName),
decoderCodecName_(_decoderCodecName),
hardware_(_hardware),
hardwareReason_(_hardwareReason),
conversion_(_conversion),
shouldDecoderAlwaysBeRecycled_(_shouldDecoderAlwaysBeRecycled)
{
}
MOZ_IMPLICIT InitCompletionIPDL(
TrackType&& _type,
nsCString&& _decoderDescription,
nsCString&& _decoderProcessName,
nsCString&& _decoderCodecName,
bool&& _hardware,
nsCString&& _hardwareReason,
ConversionRequired&& _conversion,
bool&& _shouldDecoderAlwaysBeRecycled) :
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))
{
}
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_;
}
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_;
};
} // 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(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_Construct(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_Init(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_Init(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_Decode(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_Decode(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_Flush(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_Flush(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_Drain(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_Drain(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_Shutdown(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_Shutdown(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_SetSeekThreshold(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg___delete__(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply___delete__(int32_t routingId);
} // namespace PRemoteDecoder
} // namespace mozilla
#endif // ifndef PRemoteDecoder_h