Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#ifndef PMFMediaEngine_h
#define PMFMediaEngine_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 "mozilla/ipc/IPDLStructMember.h"
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct MediaInfoIPDL|
//
namespace mozilla {
class MediaInfoIPDL final
{
private:
typedef ::mozilla::AudioInfo AudioInfo;
typedef ::mozilla::VideoInfo VideoInfo;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
MediaInfoIPDL() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT MediaInfoIPDL(
const mozilla::Maybe<AudioInfo>& _audioInfo,
const mozilla::Maybe<VideoInfo>& _videoInfo) :
audioInfo_(_audioInfo),
videoInfo_(_videoInfo)
{
}
MOZ_IMPLICIT MediaInfoIPDL(
mozilla::Maybe<AudioInfo>&& _audioInfo,
mozilla::Maybe<VideoInfo>&& _videoInfo) :
audioInfo_(std::move(_audioInfo)),
videoInfo_(std::move(_videoInfo))
{
}
mozilla::Maybe<AudioInfo>&
audioInfo()
{
return audioInfo_;
}
const mozilla::Maybe<AudioInfo>&
audioInfo() const
{
return audioInfo_;
}
mozilla::Maybe<VideoInfo>&
videoInfo()
{
return videoInfo_;
}
const mozilla::Maybe<VideoInfo>&
videoInfo() const
{
return videoInfo_;
}
private:
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<AudioInfo>> audioInfo_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<VideoInfo>> videoInfo_;
};
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::MediaInfoIPDL>
{
typedef ::mozilla::MediaInfoIPDL 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 MediaEngineInfoIPDL|
//
namespace mozilla {
class MediaEngineInfoIPDL final
{
private:
typedef ::mozilla::MediaInfoIPDL MediaInfoIPDL;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
MediaEngineInfoIPDL() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT MediaEngineInfoIPDL(
const MediaInfoIPDL& _mediaInfo,
const bool& _preload,
const bool& _encryptedCustomIdent) :
mediaInfo_(_mediaInfo),
preload_(_preload),
encryptedCustomIdent_(_encryptedCustomIdent)
{
}
MOZ_IMPLICIT MediaEngineInfoIPDL(
MediaInfoIPDL&& _mediaInfo,
bool&& _preload,
bool&& _encryptedCustomIdent) :
mediaInfo_(std::move(_mediaInfo)),
preload_(std::move(_preload)),
encryptedCustomIdent_(std::move(_encryptedCustomIdent))
{
}
MediaInfoIPDL&
mediaInfo()
{
return mediaInfo_;
}
const MediaInfoIPDL&
mediaInfo() const
{
return mediaInfo_;
}
bool&
preload()
{
return preload_;
}
const bool&
preload() const
{
return preload_;
}
bool&
encryptedCustomIdent()
{
return encryptedCustomIdent_;
}
const bool&
encryptedCustomIdent() const
{
return encryptedCustomIdent_;
}
private:
::mozilla::ipc::IPDLStructMember<MediaInfoIPDL> mediaInfo_;
::mozilla::ipc::IPDLStructMember<bool> preload_;
::mozilla::ipc::IPDLStructMember<bool> encryptedCustomIdent_;
};
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::MediaEngineInfoIPDL>
{
typedef ::mozilla::MediaEngineInfoIPDL 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 StatisticData|
//
namespace mozilla {
class StatisticData final
{
private:
typedef ::uint64_t uint64_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
StatisticData() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT StatisticData(
const uint64_t& _renderedFrames,
const uint64_t& _droppedFrames) :
renderedFrames_(_renderedFrames),
droppedFrames_(_droppedFrames)
{
}
MOZ_IMPLICIT StatisticData(
uint64_t&& _renderedFrames,
uint64_t&& _droppedFrames) :
renderedFrames_(std::move(_renderedFrames)),
droppedFrames_(std::move(_droppedFrames))
{
}
uint64_t&
renderedFrames()
{
return renderedFrames_;
}
const uint64_t&
renderedFrames() const
{
return renderedFrames_;
}
uint64_t&
droppedFrames()
{
return droppedFrames_;
}
const uint64_t&
droppedFrames() const
{
return droppedFrames_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<uint64_t> renderedFrames_;
::mozilla::ipc::IPDLStructMember<uint64_t> droppedFrames_;
};
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::StatisticData>
{
typedef ::mozilla::StatisticData paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
namespace mozilla {
class PMFMediaEngineParent;
} // namespace mozilla
namespace mozilla {
class PMFMediaEngineChild;
} // namespace mozilla
//-----------------------------------------------------------------------------
// Code common to PMFMediaEngineChild and PMFMediaEngineParent
//
namespace mozilla {
namespace PMFMediaEngine {
nsresult
CreateEndpoints(
mozilla::ipc::EndpointProcInfo aParentDestInfo,
mozilla::ipc::EndpointProcInfo aChildDestInfo,
mozilla::ipc::Endpoint<::mozilla::PMFMediaEngineParent>* aParent,
mozilla::ipc::Endpoint<::mozilla::PMFMediaEngineChild>* aChild);
enum MessageType {
PMFMediaEngineStart = PMFMediaEngineMsgStart << 16,
Msg_InitMediaEngine__ID,
Reply_InitMediaEngine__ID,
Msg_Play__ID,
Msg_Pause__ID,
Msg_Seek__ID,
Msg_SetCDMProxyId__ID,
Msg_SetVolume__ID,
Msg_SetPlaybackRate__ID,
Msg_SetLooping__ID,
Msg_NotifyEndOfStream__ID,
Msg_Shutdown__ID,
Msg___delete____ID,
Reply___delete____ID,
Msg_NotifyEvent__ID,
Msg_NotifyError__ID,
Msg_UpdateCurrentTime__ID,
Msg_RequestSample__ID,
Msg_UpdateStatisticData__ID,
Msg_NotifyResizing__ID,
PMFMediaEngineEnd
};
mozilla::UniquePtr<IPC::Message>
Msg_InitMediaEngine(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_InitMediaEngine(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_Play(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_Pause(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_Seek(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_SetCDMProxyId(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_SetVolume(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_SetPlaybackRate(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_SetLooping(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_NotifyEndOfStream(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_Shutdown(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg___delete__(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply___delete__(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_NotifyEvent(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_NotifyError(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_UpdateCurrentTime(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_RequestSample(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_UpdateStatisticData(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_NotifyResizing(int32_t routingId);
} // namespace PMFMediaEngine
} // namespace mozilla
#endif // ifndef PMFMediaEngine_h