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

#ifndef PLockManager_h
#define PLockManager_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 "mozilla/dom/LockManagerBinding.h"
#include "mozilla/ipc/IPDLStructMember.h"


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct IPCLockRequest|
//
namespace mozilla {
namespace dom {
namespace locks {
class IPCLockRequest final
{
private:
    typedef ::nsString nsString;
    typedef ::mozilla::dom::LockMode LockMode;

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

    MOZ_IMPLICIT IPCLockRequest(
            const nsString& _name,
            const LockMode& _lockMode,
            const bool& _ifAvailable,
            const bool& _steal) :
        name_(_name),
        lockMode_(_lockMode),
        ifAvailable_(_ifAvailable),
        steal_(_steal)
    {
    }

    MOZ_IMPLICIT IPCLockRequest(
            nsString&& _name,
            LockMode&& _lockMode,
            bool&& _ifAvailable,
            bool&& _steal) :
        name_(std::move(_name)),
        lockMode_(std::move(_lockMode)),
        ifAvailable_(std::move(_ifAvailable)),
        steal_(std::move(_steal))
    {
    }

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

    LockMode&
    lockMode()
    {
        return lockMode_;
    }
    const LockMode&
    lockMode() const
    {
        return lockMode_;
    }

    bool&
    ifAvailable()
    {
        return ifAvailable_;
    }
    const bool&
    ifAvailable() const
    {
        return ifAvailable_;
    }

    bool&
    steal()
    {
        return steal_;
    }
    const bool&
    steal() const
    {
        return steal_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsString> name_;
    ::mozilla::ipc::IPDLStructMember<LockMode> lockMode_;
    ::mozilla::ipc::IPDLStructMember<bool> ifAvailable_;
    ::mozilla::ipc::IPDLStructMember<bool> steal_;
};
} // namespace locks
} // namespace dom
} // namespace mozilla

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

namespace mozilla {
namespace dom {
namespace locks {
class PLockManagerParent;
} // namespace locks
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
namespace locks {
class PLockManagerChild;
} // namespace locks
} // namespace dom
} // namespace mozilla

//-----------------------------------------------------------------------------
// Code common to PLockManagerChild and PLockManagerParent
//
namespace mozilla {
namespace dom {
namespace locks {
namespace PLockManager {

nsresult
CreateEndpoints(
        mozilla::ipc::EndpointProcInfo aParentDestInfo,
        mozilla::ipc::EndpointProcInfo aChildDestInfo,
        mozilla::ipc::Endpoint<::mozilla::dom::locks::PLockManagerParent>* aParent,
        mozilla::ipc::Endpoint<::mozilla::dom::locks::PLockManagerChild>* aChild);

enum MessageType {
    PLockManagerStart = PLockManagerMsgStart << 16,
    Msg_Query__ID,
    Reply_Query__ID,
    Msg_PLockRequestConstructor__ID,
    Reply_PLockRequestConstructor__ID,
    Msg___delete____ID,
    Reply___delete____ID,
    PLockManagerEnd
};

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

mozilla::UniquePtr<IPC::Message>
Msg_PLockRequestConstructor(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_PLockRequestConstructor(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 PLockManager
} // namespace locks
} // namespace dom
} // namespace mozilla

#endif // ifndef PLockManager_h
