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

#ifndef GMPTypes_h
#define GMPTypes_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 "GMPSanitizedExports.h"
#include "gmp-video-codec.h"
#include "mozilla/ipc/IPDLStructMember.h"


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct NodeIdParts|
//
namespace mozilla {
namespace gmp {
class NodeIdParts final
{
private:
    typedef ::nsString nsString;

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

    MOZ_IMPLICIT NodeIdParts(
            const nsString& _mOrigin,
            const nsString& _mTopLevelOrigin,
            const nsString& _mGMPName) :
        mOrigin_(_mOrigin),
        mTopLevelOrigin_(_mTopLevelOrigin),
        mGMPName_(_mGMPName)
    {
    }

    MOZ_IMPLICIT NodeIdParts(
            nsString&& _mOrigin,
            nsString&& _mTopLevelOrigin,
            nsString&& _mGMPName) :
        mOrigin_(std::move(_mOrigin)),
        mTopLevelOrigin_(std::move(_mTopLevelOrigin)),
        mGMPName_(std::move(_mGMPName))
    {
    }

    nsString&
    mOrigin()
    {
        return mOrigin_;
    }
    const nsString&
    mOrigin() const
    {
        return mOrigin_;
    }

    nsString&
    mTopLevelOrigin()
    {
        return mTopLevelOrigin_;
    }
    const nsString&
    mTopLevelOrigin() const
    {
        return mTopLevelOrigin_;
    }

    nsString&
    mGMPName()
    {
        return mGMPName_;
    }
    const nsString&
    mGMPName() const
    {
        return mGMPName_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsString> mOrigin_;
    ::mozilla::ipc::IPDLStructMember<nsString> mTopLevelOrigin_;
    ::mozilla::ipc::IPDLStructMember<nsString> mGMPName_;
};
} // namespace gmp
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::gmp::NodeIdParts>
{
    typedef ::mozilla::gmp::NodeIdParts 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 NodeIdVariant|
//
namespace mozilla {
namespace gmp {
class NodeIdVariant final
{
public:
    enum Type {
        T__None,
        TnsCString = 1,
        TNodeIdParts,
        T__Last = TNodeIdParts
    };

private:
    typedef ::nsCString nsCString;
    typedef ::mozilla::gmp::NodeIdParts NodeIdParts;
    typedef nsCString nsCString__tdef;
    typedef NodeIdParts NodeIdParts__tdef;

    nsCString*
    ptr_nsCString()
    {
        return (&(mVnsCString));
    }
    const nsCString*
    constptr_nsCString() const
    {
        return (&(mVnsCString));
    }
    NodeIdParts*
    ptr_NodeIdParts()
    {
        return (&(mVNodeIdParts));
    }
    const NodeIdParts*
    constptr_NodeIdParts() const
    {
        return (&(mVNodeIdParts));
    }

    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 NodeIdVariant() :
        mType(T__None)
    {
    }

    MOZ_IMPLICIT NodeIdVariant(const nsCString& aOther);

    MOZ_IMPLICIT NodeIdVariant(nsCString&& aOther);

    MOZ_IMPLICIT NodeIdVariant(const NodeIdParts& aOther);

    MOZ_IMPLICIT NodeIdVariant(NodeIdParts&& aOther);

    MOZ_IMPLICIT NodeIdVariant(const NodeIdVariant& aOther);

    MOZ_IMPLICIT NodeIdVariant(NodeIdVariant&& aOther);

    ~NodeIdVariant();

    Type
    type() const
    {
        return mType;
    }

    NodeIdVariant&
    operator=(const nsCString& aRhs);

    NodeIdVariant&
    operator=(nsCString&& aRhs);

    NodeIdVariant&
    operator=(const NodeIdParts& aRhs);

    NodeIdVariant&
    operator=(NodeIdParts&& aRhs);

    NodeIdVariant&
    operator=(const NodeIdVariant& aRhs);

    NodeIdVariant&
    operator=(NodeIdVariant&& aRhs);

    nsCString&
    get_nsCString()
    {
        AssertSanity(TnsCString);
        return (*(ptr_nsCString()));
    }
    const nsCString&
    get_nsCString() const
    {
        AssertSanity(TnsCString);
        return (*(constptr_nsCString()));
    }
    operator nsCString&()
    {
        return get_nsCString();
    }
    operator const nsCString&() const
    {
        return get_nsCString();
    }

    NodeIdParts&
    get_NodeIdParts()
    {
        AssertSanity(TNodeIdParts);
        return (*(ptr_NodeIdParts()));
    }
    const NodeIdParts&
    get_NodeIdParts() const
    {
        AssertSanity(TNodeIdParts);
        return (*(constptr_NodeIdParts()));
    }
    operator NodeIdParts&()
    {
        return get_NodeIdParts();
    }
    operator const NodeIdParts&() const
    {
        return get_NodeIdParts();
    }

private:
    union {
        nsCString mVnsCString;
        NodeIdParts mVNodeIdParts;
    };
    Type mType;
};
} // namespace gmp
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::gmp::NodeIdVariant>
{
    typedef ::mozilla::gmp::NodeIdVariant 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 GMPVideoEncodedFrameData|
//
namespace mozilla {
namespace gmp {
class GMPVideoEncodedFrameData final
{
private:
    typedef ::uint32_t uint32_t;
    typedef ::uint64_t uint64_t;
    typedef ::int32_t int32_t;
    typedef ::GMPBufferType GMPBufferType;

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

    MOZ_IMPLICIT GMPVideoEncodedFrameData(
            const uint32_t& _mEncodedWidth,
            const uint32_t& _mEncodedHeight,
            const uint64_t& _mTimestamp,
            const uint64_t& _mDuration,
            const uint32_t& _mFrameType,
            const uint32_t& _mSize,
            const int32_t& _mTemporalLayerId,
            const GMPBufferType& _mBufferType,
            const bool& _mCompleteFrame) :
        mBufferType_(_mBufferType),
        mCompleteFrame_(_mCompleteFrame),
        mTimestamp_(_mTimestamp),
        mDuration_(_mDuration),
        mEncodedWidth_(_mEncodedWidth),
        mEncodedHeight_(_mEncodedHeight),
        mFrameType_(_mFrameType),
        mSize_(_mSize),
        mTemporalLayerId_(_mTemporalLayerId)
    {
    }

    MOZ_IMPLICIT GMPVideoEncodedFrameData(
            uint32_t&& _mEncodedWidth,
            uint32_t&& _mEncodedHeight,
            uint64_t&& _mTimestamp,
            uint64_t&& _mDuration,
            uint32_t&& _mFrameType,
            uint32_t&& _mSize,
            int32_t&& _mTemporalLayerId,
            GMPBufferType&& _mBufferType,
            bool&& _mCompleteFrame) :
        mBufferType_(std::move(_mBufferType)),
        mCompleteFrame_(std::move(_mCompleteFrame)),
        mTimestamp_(std::move(_mTimestamp)),
        mDuration_(std::move(_mDuration)),
        mEncodedWidth_(std::move(_mEncodedWidth)),
        mEncodedHeight_(std::move(_mEncodedHeight)),
        mFrameType_(std::move(_mFrameType)),
        mSize_(std::move(_mSize)),
        mTemporalLayerId_(std::move(_mTemporalLayerId))
    {
    }

    uint32_t&
    mEncodedWidth()
    {
        return mEncodedWidth_;
    }
    const uint32_t&
    mEncodedWidth() const
    {
        return mEncodedWidth_;
    }

    uint32_t&
    mEncodedHeight()
    {
        return mEncodedHeight_;
    }
    const uint32_t&
    mEncodedHeight() const
    {
        return mEncodedHeight_;
    }

    uint64_t&
    mTimestamp()
    {
        return mTimestamp_;
    }
    const uint64_t&
    mTimestamp() const
    {
        return mTimestamp_;
    }

    uint64_t&
    mDuration()
    {
        return mDuration_;
    }
    const uint64_t&
    mDuration() const
    {
        return mDuration_;
    }

    uint32_t&
    mFrameType()
    {
        return mFrameType_;
    }
    const uint32_t&
    mFrameType() const
    {
        return mFrameType_;
    }

    uint32_t&
    mSize()
    {
        return mSize_;
    }
    const uint32_t&
    mSize() const
    {
        return mSize_;
    }

    int32_t&
    mTemporalLayerId()
    {
        return mTemporalLayerId_;
    }
    const int32_t&
    mTemporalLayerId() const
    {
        return mTemporalLayerId_;
    }

    GMPBufferType&
    mBufferType()
    {
        return mBufferType_;
    }
    const GMPBufferType&
    mBufferType() const
    {
        return mBufferType_;
    }

    bool&
    mCompleteFrame()
    {
        return mCompleteFrame_;
    }
    const bool&
    mCompleteFrame() const
    {
        return mCompleteFrame_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<GMPBufferType> mBufferType_;
    ::mozilla::ipc::IPDLStructMember<bool> mCompleteFrame_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> mTimestamp_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> mDuration_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> mEncodedWidth_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> mEncodedHeight_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> mFrameType_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> mSize_;
    ::mozilla::ipc::IPDLStructMember<int32_t> mTemporalLayerId_;
};
} // namespace gmp
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::gmp::GMPVideoEncodedFrameData>
{
    typedef ::mozilla::gmp::GMPVideoEncodedFrameData 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 GMPPlaneData|
//
namespace mozilla {
namespace gmp {
class GMPPlaneData final
{
private:
    typedef ::int32_t int32_t;

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

    MOZ_IMPLICIT GMPPlaneData(
            const int32_t& _mOffset,
            const int32_t& _mSize,
            const int32_t& _mStride) :
        mOffset_(_mOffset),
        mSize_(_mSize),
        mStride_(_mStride)
    {
    }

    MOZ_IMPLICIT GMPPlaneData(
            int32_t&& _mOffset,
            int32_t&& _mSize,
            int32_t&& _mStride) :
        mOffset_(std::move(_mOffset)),
        mSize_(std::move(_mSize)),
        mStride_(std::move(_mStride))
    {
    }

    int32_t&
    mOffset()
    {
        return mOffset_;
    }
    const int32_t&
    mOffset() const
    {
        return mOffset_;
    }

    int32_t&
    mSize()
    {
        return mSize_;
    }
    const int32_t&
    mSize() const
    {
        return mSize_;
    }

    int32_t&
    mStride()
    {
        return mStride_;
    }
    const int32_t&
    mStride() const
    {
        return mStride_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<int32_t> mOffset_;
    ::mozilla::ipc::IPDLStructMember<int32_t> mSize_;
    ::mozilla::ipc::IPDLStructMember<int32_t> mStride_;
};
} // namespace gmp
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::gmp::GMPPlaneData>
{
    typedef ::mozilla::gmp::GMPPlaneData 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 GMPVideoi420FrameData|
//
namespace mozilla {
namespace gmp {
class GMPVideoi420FrameData final
{
private:
    typedef ::mozilla::gmp::GMPPlaneData GMPPlaneData;
    typedef ::int32_t int32_t;
    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
    GMPVideoi420FrameData() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT GMPVideoi420FrameData(
            const GMPPlaneData& _mYPlane,
            const GMPPlaneData& _mUPlane,
            const GMPPlaneData& _mVPlane,
            const int32_t& _mWidth,
            const int32_t& _mHeight,
            const uint64_t& _mTimestamp,
            const mozilla::Maybe<uint64_t>& _mUpdatedTimestamp,
            const uint64_t& _mDuration) :
        mYPlane_(_mYPlane),
        mUPlane_(_mUPlane),
        mVPlane_(_mVPlane),
        mUpdatedTimestamp_(_mUpdatedTimestamp),
        mTimestamp_(_mTimestamp),
        mDuration_(_mDuration),
        mWidth_(_mWidth),
        mHeight_(_mHeight)
    {
    }

    MOZ_IMPLICIT GMPVideoi420FrameData(
            GMPPlaneData&& _mYPlane,
            GMPPlaneData&& _mUPlane,
            GMPPlaneData&& _mVPlane,
            int32_t&& _mWidth,
            int32_t&& _mHeight,
            uint64_t&& _mTimestamp,
            mozilla::Maybe<uint64_t>&& _mUpdatedTimestamp,
            uint64_t&& _mDuration) :
        mYPlane_(std::move(_mYPlane)),
        mUPlane_(std::move(_mUPlane)),
        mVPlane_(std::move(_mVPlane)),
        mUpdatedTimestamp_(std::move(_mUpdatedTimestamp)),
        mTimestamp_(std::move(_mTimestamp)),
        mDuration_(std::move(_mDuration)),
        mWidth_(std::move(_mWidth)),
        mHeight_(std::move(_mHeight))
    {
    }

    GMPPlaneData&
    mYPlane()
    {
        return mYPlane_;
    }
    const GMPPlaneData&
    mYPlane() const
    {
        return mYPlane_;
    }

    GMPPlaneData&
    mUPlane()
    {
        return mUPlane_;
    }
    const GMPPlaneData&
    mUPlane() const
    {
        return mUPlane_;
    }

    GMPPlaneData&
    mVPlane()
    {
        return mVPlane_;
    }
    const GMPPlaneData&
    mVPlane() const
    {
        return mVPlane_;
    }

    int32_t&
    mWidth()
    {
        return mWidth_;
    }
    const int32_t&
    mWidth() const
    {
        return mWidth_;
    }

    int32_t&
    mHeight()
    {
        return mHeight_;
    }
    const int32_t&
    mHeight() const
    {
        return mHeight_;
    }

    uint64_t&
    mTimestamp()
    {
        return mTimestamp_;
    }
    const uint64_t&
    mTimestamp() const
    {
        return mTimestamp_;
    }

    mozilla::Maybe<uint64_t>&
    mUpdatedTimestamp()
    {
        return mUpdatedTimestamp_;
    }
    const mozilla::Maybe<uint64_t>&
    mUpdatedTimestamp() const
    {
        return mUpdatedTimestamp_;
    }

    uint64_t&
    mDuration()
    {
        return mDuration_;
    }
    const uint64_t&
    mDuration() const
    {
        return mDuration_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<GMPPlaneData> mYPlane_;
    ::mozilla::ipc::IPDLStructMember<GMPPlaneData> mUPlane_;
    ::mozilla::ipc::IPDLStructMember<GMPPlaneData> mVPlane_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<uint64_t>> mUpdatedTimestamp_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> mTimestamp_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> mDuration_;
    ::mozilla::ipc::IPDLStructMember<int32_t> mWidth_;
    ::mozilla::ipc::IPDLStructMember<int32_t> mHeight_;
};
} // namespace gmp
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::gmp::GMPVideoi420FrameData>
{
    typedef ::mozilla::gmp::GMPVideoi420FrameData 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 CDMInputBuffer|
//
namespace mozilla {
namespace gmp {
class CDMInputBuffer final
{
private:
    typedef ::mozilla::ipc::Shmem Shmem;
    typedef ::uint8_t uint8_t;
    typedef ::int64_t int64_t;
    typedef ::uint32_t uint32_t;
    typedef ::cdm::EncryptionScheme EncryptionScheme;

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

    MOZ_IMPLICIT CDMInputBuffer(
            Shmem& _mData,
            const nsTArray<uint8_t>& _mKeyId,
            const nsTArray<uint8_t>& _mIV,
            const int64_t& _mTimestamp,
            const int64_t& _mDuration,
            const nsTArray<uint32_t>& _mClearBytes,
            const nsTArray<uint32_t>& _mCipherBytes,
            const uint8_t& _mCryptByteBlock,
            const uint8_t& _mSkipByteBlock,
            const EncryptionScheme& _mEncryptionScheme) :
        mData_(_mData),
        mKeyId_(_mKeyId),
        mIV_(_mIV),
        mClearBytes_(_mClearBytes),
        mCipherBytes_(_mCipherBytes),
        mEncryptionScheme_(_mEncryptionScheme),
        mTimestamp_(_mTimestamp),
        mDuration_(_mDuration),
        mCryptByteBlock_(_mCryptByteBlock),
        mSkipByteBlock_(_mSkipByteBlock)
    {
    }

    MOZ_IMPLICIT CDMInputBuffer(
            Shmem&& _mData,
            nsTArray<uint8_t>&& _mKeyId,
            nsTArray<uint8_t>&& _mIV,
            int64_t&& _mTimestamp,
            int64_t&& _mDuration,
            nsTArray<uint32_t>&& _mClearBytes,
            nsTArray<uint32_t>&& _mCipherBytes,
            uint8_t&& _mCryptByteBlock,
            uint8_t&& _mSkipByteBlock,
            EncryptionScheme&& _mEncryptionScheme) :
        mData_(std::move(_mData)),
        mKeyId_(std::move(_mKeyId)),
        mIV_(std::move(_mIV)),
        mClearBytes_(std::move(_mClearBytes)),
        mCipherBytes_(std::move(_mCipherBytes)),
        mEncryptionScheme_(std::move(_mEncryptionScheme)),
        mTimestamp_(std::move(_mTimestamp)),
        mDuration_(std::move(_mDuration)),
        mCryptByteBlock_(std::move(_mCryptByteBlock)),
        mSkipByteBlock_(std::move(_mSkipByteBlock))
    {
    }

    Shmem&
    mData()
    {
        return mData_;
    }
    Shmem&
    mData() const
    {
        return const_cast<Shmem&>(mData_);
    }

    nsTArray<uint8_t>&
    mKeyId()
    {
        return mKeyId_;
    }
    const nsTArray<uint8_t>&
    mKeyId() const
    {
        return mKeyId_;
    }

    nsTArray<uint8_t>&
    mIV()
    {
        return mIV_;
    }
    const nsTArray<uint8_t>&
    mIV() const
    {
        return mIV_;
    }

    int64_t&
    mTimestamp()
    {
        return mTimestamp_;
    }
    const int64_t&
    mTimestamp() const
    {
        return mTimestamp_;
    }

    int64_t&
    mDuration()
    {
        return mDuration_;
    }
    const int64_t&
    mDuration() const
    {
        return mDuration_;
    }

    nsTArray<uint32_t>&
    mClearBytes()
    {
        return mClearBytes_;
    }
    const nsTArray<uint32_t>&
    mClearBytes() const
    {
        return mClearBytes_;
    }

    nsTArray<uint32_t>&
    mCipherBytes()
    {
        return mCipherBytes_;
    }
    const nsTArray<uint32_t>&
    mCipherBytes() const
    {
        return mCipherBytes_;
    }

    uint8_t&
    mCryptByteBlock()
    {
        return mCryptByteBlock_;
    }
    const uint8_t&
    mCryptByteBlock() const
    {
        return mCryptByteBlock_;
    }

    uint8_t&
    mSkipByteBlock()
    {
        return mSkipByteBlock_;
    }
    const uint8_t&
    mSkipByteBlock() const
    {
        return mSkipByteBlock_;
    }

    EncryptionScheme&
    mEncryptionScheme()
    {
        return mEncryptionScheme_;
    }
    const EncryptionScheme&
    mEncryptionScheme() const
    {
        return mEncryptionScheme_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<Shmem> mData_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> mKeyId_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> mIV_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint32_t>> mClearBytes_;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint32_t>> mCipherBytes_;
    ::mozilla::ipc::IPDLStructMember<EncryptionScheme> mEncryptionScheme_;
    ::mozilla::ipc::IPDLStructMember<int64_t> mTimestamp_;
    ::mozilla::ipc::IPDLStructMember<int64_t> mDuration_;
    ::mozilla::ipc::IPDLStructMember<uint8_t> mCryptByteBlock_;
    ::mozilla::ipc::IPDLStructMember<uint8_t> mSkipByteBlock_;
};
} // namespace gmp
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::gmp::CDMInputBuffer>
{
    typedef ::mozilla::gmp::CDMInputBuffer 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 CDMVideoDecoderConfig|
//
namespace mozilla {
namespace gmp {
class CDMVideoDecoderConfig final
{
private:
    typedef ::uint32_t uint32_t;
    typedef ::int32_t int32_t;
    typedef ::uint8_t uint8_t;
    typedef ::cdm::EncryptionScheme EncryptionScheme;

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

    MOZ_IMPLICIT CDMVideoDecoderConfig(
            const uint32_t& _mCodec,
            const uint32_t& _mProfile,
            const uint32_t& _mFormat,
            const int32_t& _mImageWidth,
            const int32_t& _mImageHeight,
            const nsTArray<uint8_t>& _mExtraData,
            const EncryptionScheme& _mEncryptionScheme) :
        mExtraData_(_mExtraData),
        mEncryptionScheme_(_mEncryptionScheme),
        mCodec_(_mCodec),
        mProfile_(_mProfile),
        mFormat_(_mFormat),
        mImageWidth_(_mImageWidth),
        mImageHeight_(_mImageHeight)
    {
    }

    MOZ_IMPLICIT CDMVideoDecoderConfig(
            uint32_t&& _mCodec,
            uint32_t&& _mProfile,
            uint32_t&& _mFormat,
            int32_t&& _mImageWidth,
            int32_t&& _mImageHeight,
            nsTArray<uint8_t>&& _mExtraData,
            EncryptionScheme&& _mEncryptionScheme) :
        mExtraData_(std::move(_mExtraData)),
        mEncryptionScheme_(std::move(_mEncryptionScheme)),
        mCodec_(std::move(_mCodec)),
        mProfile_(std::move(_mProfile)),
        mFormat_(std::move(_mFormat)),
        mImageWidth_(std::move(_mImageWidth)),
        mImageHeight_(std::move(_mImageHeight))
    {
    }

    uint32_t&
    mCodec()
    {
        return mCodec_;
    }
    const uint32_t&
    mCodec() const
    {
        return mCodec_;
    }

    uint32_t&
    mProfile()
    {
        return mProfile_;
    }
    const uint32_t&
    mProfile() const
    {
        return mProfile_;
    }

    uint32_t&
    mFormat()
    {
        return mFormat_;
    }
    const uint32_t&
    mFormat() const
    {
        return mFormat_;
    }

    int32_t&
    mImageWidth()
    {
        return mImageWidth_;
    }
    const int32_t&
    mImageWidth() const
    {
        return mImageWidth_;
    }

    int32_t&
    mImageHeight()
    {
        return mImageHeight_;
    }
    const int32_t&
    mImageHeight() const
    {
        return mImageHeight_;
    }

    nsTArray<uint8_t>&
    mExtraData()
    {
        return mExtraData_;
    }
    const nsTArray<uint8_t>&
    mExtraData() const
    {
        return mExtraData_;
    }

    EncryptionScheme&
    mEncryptionScheme()
    {
        return mEncryptionScheme_;
    }
    const EncryptionScheme&
    mEncryptionScheme() const
    {
        return mEncryptionScheme_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> mExtraData_;
    ::mozilla::ipc::IPDLStructMember<EncryptionScheme> mEncryptionScheme_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> mCodec_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> mProfile_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> mFormat_;
    ::mozilla::ipc::IPDLStructMember<int32_t> mImageWidth_;
    ::mozilla::ipc::IPDLStructMember<int32_t> mImageHeight_;
};
} // namespace gmp
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::gmp::CDMVideoDecoderConfig>
{
    typedef ::mozilla::gmp::CDMVideoDecoderConfig 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 CDMKeyInformation|
//
namespace mozilla {
namespace gmp {
class CDMKeyInformation final
{
private:
    typedef ::uint8_t uint8_t;
    typedef ::uint32_t uint32_t;

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

    MOZ_IMPLICIT CDMKeyInformation(
            const nsTArray<uint8_t>& _mKeyId,
            const uint32_t& _mStatus,
            const uint32_t& _mSystemCode) :
        mKeyId_(_mKeyId),
        mStatus_(_mStatus),
        mSystemCode_(_mSystemCode)
    {
    }

    MOZ_IMPLICIT CDMKeyInformation(
            nsTArray<uint8_t>&& _mKeyId,
            uint32_t&& _mStatus,
            uint32_t&& _mSystemCode) :
        mKeyId_(std::move(_mKeyId)),
        mStatus_(std::move(_mStatus)),
        mSystemCode_(std::move(_mSystemCode))
    {
    }

    nsTArray<uint8_t>&
    mKeyId()
    {
        return mKeyId_;
    }
    const nsTArray<uint8_t>&
    mKeyId() const
    {
        return mKeyId_;
    }

    uint32_t&
    mStatus()
    {
        return mStatus_;
    }
    const uint32_t&
    mStatus() const
    {
        return mStatus_;
    }

    uint32_t&
    mSystemCode()
    {
        return mSystemCode_;
    }
    const uint32_t&
    mSystemCode() const
    {
        return mSystemCode_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<uint8_t>> mKeyId_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> mStatus_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> mSystemCode_;
};
} // namespace gmp
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::gmp::CDMKeyInformation>
{
    typedef ::mozilla::gmp::CDMKeyInformation 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 CDMVideoPlane|
//
namespace mozilla {
namespace gmp {
class CDMVideoPlane final
{
private:
    typedef ::uint32_t uint32_t;

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

    MOZ_IMPLICIT CDMVideoPlane(
            const uint32_t& _mPlaneOffset,
            const uint32_t& _mStride) :
        mPlaneOffset_(_mPlaneOffset),
        mStride_(_mStride)
    {
    }

    MOZ_IMPLICIT CDMVideoPlane(
            uint32_t&& _mPlaneOffset,
            uint32_t&& _mStride) :
        mPlaneOffset_(std::move(_mPlaneOffset)),
        mStride_(std::move(_mStride))
    {
    }

    uint32_t&
    mPlaneOffset()
    {
        return mPlaneOffset_;
    }
    const uint32_t&
    mPlaneOffset() const
    {
        return mPlaneOffset_;
    }

    uint32_t&
    mStride()
    {
        return mStride_;
    }
    const uint32_t&
    mStride() const
    {
        return mStride_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<uint32_t> mPlaneOffset_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> mStride_;
};
} // namespace gmp
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::gmp::CDMVideoPlane>
{
    typedef ::mozilla::gmp::CDMVideoPlane 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 CDMVideoFrame|
//
namespace mozilla {
namespace gmp {
class CDMVideoFrame final
{
private:
    typedef ::uint32_t uint32_t;
    typedef ::int32_t int32_t;
    typedef ::mozilla::gmp::CDMVideoPlane CDMVideoPlane;
    typedef ::int64_t int64_t;

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

    MOZ_IMPLICIT CDMVideoFrame(
            const uint32_t& _mFormat,
            const int32_t& _mImageWidth,
            const int32_t& _mImageHeight,
            const CDMVideoPlane& _mYPlane,
            const CDMVideoPlane& _mUPlane,
            const CDMVideoPlane& _mVPlane,
            const int64_t& _mTimestamp,
            const int64_t& _mDuration) :
        mYPlane_(_mYPlane),
        mUPlane_(_mUPlane),
        mVPlane_(_mVPlane),
        mTimestamp_(_mTimestamp),
        mDuration_(_mDuration),
        mFormat_(_mFormat),
        mImageWidth_(_mImageWidth),
        mImageHeight_(_mImageHeight)
    {
    }

    MOZ_IMPLICIT CDMVideoFrame(
            uint32_t&& _mFormat,
            int32_t&& _mImageWidth,
            int32_t&& _mImageHeight,
            CDMVideoPlane&& _mYPlane,
            CDMVideoPlane&& _mUPlane,
            CDMVideoPlane&& _mVPlane,
            int64_t&& _mTimestamp,
            int64_t&& _mDuration) :
        mYPlane_(std::move(_mYPlane)),
        mUPlane_(std::move(_mUPlane)),
        mVPlane_(std::move(_mVPlane)),
        mTimestamp_(std::move(_mTimestamp)),
        mDuration_(std::move(_mDuration)),
        mFormat_(std::move(_mFormat)),
        mImageWidth_(std::move(_mImageWidth)),
        mImageHeight_(std::move(_mImageHeight))
    {
    }

    uint32_t&
    mFormat()
    {
        return mFormat_;
    }
    const uint32_t&
    mFormat() const
    {
        return mFormat_;
    }

    int32_t&
    mImageWidth()
    {
        return mImageWidth_;
    }
    const int32_t&
    mImageWidth() const
    {
        return mImageWidth_;
    }

    int32_t&
    mImageHeight()
    {
        return mImageHeight_;
    }
    const int32_t&
    mImageHeight() const
    {
        return mImageHeight_;
    }

    CDMVideoPlane&
    mYPlane()
    {
        return mYPlane_;
    }
    const CDMVideoPlane&
    mYPlane() const
    {
        return mYPlane_;
    }

    CDMVideoPlane&
    mUPlane()
    {
        return mUPlane_;
    }
    const CDMVideoPlane&
    mUPlane() const
    {
        return mUPlane_;
    }

    CDMVideoPlane&
    mVPlane()
    {
        return mVPlane_;
    }
    const CDMVideoPlane&
    mVPlane() const
    {
        return mVPlane_;
    }

    int64_t&
    mTimestamp()
    {
        return mTimestamp_;
    }
    const int64_t&
    mTimestamp() const
    {
        return mTimestamp_;
    }

    int64_t&
    mDuration()
    {
        return mDuration_;
    }
    const int64_t&
    mDuration() const
    {
        return mDuration_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<CDMVideoPlane> mYPlane_;
    ::mozilla::ipc::IPDLStructMember<CDMVideoPlane> mUPlane_;
    ::mozilla::ipc::IPDLStructMember<CDMVideoPlane> mVPlane_;
    ::mozilla::ipc::IPDLStructMember<int64_t> mTimestamp_;
    ::mozilla::ipc::IPDLStructMember<int64_t> mDuration_;
    ::mozilla::ipc::IPDLStructMember<uint32_t> mFormat_;
    ::mozilla::ipc::IPDLStructMember<int32_t> mImageWidth_;
    ::mozilla::ipc::IPDLStructMember<int32_t> mImageHeight_;
};
} // namespace gmp
} // namespace mozilla

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

#endif // ifndef GMPTypes_h
