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

#ifndef PBackgroundLSSnapshot_h
#define PBackgroundLSSnapshot_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/LSValue.h"
#include "mozilla/ipc/IPDLStructMember.h"
#include "mozilla/dom/PBackgroundLSSharedTypes.h"


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

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

    MOZ_IMPLICIT LSSetItemInfo(
            const nsString& _key,
            const LSValue& _value) :
        key_(_key),
        value_(_value)
    {
    }

    MOZ_IMPLICIT LSSetItemInfo(
            nsString&& _key,
            LSValue&& _value) :
        key_(std::move(_key)),
        value_(std::move(_value))
    {
    }

    nsString&
    key()
    {
        return key_;
    }
    const nsString&
    key() const
    {
        return key_;
    }

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

private:
    ::mozilla::ipc::IPDLStructMember<nsString> key_;
    ::mozilla::ipc::IPDLStructMember<LSValue> value_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::LSSetItemInfo>
{
    typedef ::mozilla::dom::LSSetItemInfo 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 LSRemoveItemInfo|
//
namespace mozilla {
namespace dom {
class LSRemoveItemInfo 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
    LSRemoveItemInfo() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT LSRemoveItemInfo(const nsString& _key) :
        key_(_key)
    {
    }

    MOZ_IMPLICIT LSRemoveItemInfo(nsString&& _key) :
        key_(std::move(_key))
    {
    }

    nsString&
    key()
    {
        return key_;
    }
    const nsString&
    key() const
    {
        return key_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsString> key_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::LSRemoveItemInfo>
{
    typedef ::mozilla::dom::LSRemoveItemInfo 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 LSClearInfo|
//
namespace mozilla {
namespace dom {
class LSClearInfo final
{
private:

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

private:
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::LSClearInfo>
{
    typedef ::mozilla::dom::LSClearInfo 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 LSWriteInfo|
//
namespace mozilla {
namespace dom {
class LSWriteInfo final
{
public:
    enum Type {
        T__None,
        TLSSetItemInfo = 1,
        TLSRemoveItemInfo,
        TLSClearInfo,
        T__Last = TLSClearInfo
    };

private:
    typedef ::mozilla::dom::LSSetItemInfo LSSetItemInfo;
    typedef ::mozilla::dom::LSRemoveItemInfo LSRemoveItemInfo;
    typedef ::mozilla::dom::LSClearInfo LSClearInfo;
    typedef LSSetItemInfo LSSetItemInfo__tdef;
    typedef LSRemoveItemInfo LSRemoveItemInfo__tdef;
    typedef LSClearInfo LSClearInfo__tdef;

    LSSetItemInfo*
    ptr_LSSetItemInfo()
    {
        return (&(mVLSSetItemInfo));
    }
    const LSSetItemInfo*
    constptr_LSSetItemInfo() const
    {
        return (&(mVLSSetItemInfo));
    }
    LSRemoveItemInfo*
    ptr_LSRemoveItemInfo()
    {
        return (&(mVLSRemoveItemInfo));
    }
    const LSRemoveItemInfo*
    constptr_LSRemoveItemInfo() const
    {
        return (&(mVLSRemoveItemInfo));
    }
    LSClearInfo*
    ptr_LSClearInfo()
    {
        return (&(mVLSClearInfo));
    }
    const LSClearInfo*
    constptr_LSClearInfo() const
    {
        return (&(mVLSClearInfo));
    }

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

    MOZ_IMPLICIT LSWriteInfo(const LSSetItemInfo& aOther);

    MOZ_IMPLICIT LSWriteInfo(LSSetItemInfo&& aOther);

    MOZ_IMPLICIT LSWriteInfo(const LSRemoveItemInfo& aOther);

    MOZ_IMPLICIT LSWriteInfo(LSRemoveItemInfo&& aOther);

    MOZ_IMPLICIT LSWriteInfo(const LSClearInfo& aOther);

    MOZ_IMPLICIT LSWriteInfo(LSClearInfo&& aOther);

    MOZ_IMPLICIT LSWriteInfo(const LSWriteInfo& aOther);

    MOZ_IMPLICIT LSWriteInfo(LSWriteInfo&& aOther);

    ~LSWriteInfo();

    Type
    type() const
    {
        return mType;
    }

    LSWriteInfo&
    operator=(const LSSetItemInfo& aRhs);

    LSWriteInfo&
    operator=(LSSetItemInfo&& aRhs);

    LSWriteInfo&
    operator=(const LSRemoveItemInfo& aRhs);

    LSWriteInfo&
    operator=(LSRemoveItemInfo&& aRhs);

    LSWriteInfo&
    operator=(const LSClearInfo& aRhs);

    LSWriteInfo&
    operator=(LSClearInfo&& aRhs);

    LSWriteInfo&
    operator=(const LSWriteInfo& aRhs);

    LSWriteInfo&
    operator=(LSWriteInfo&& aRhs);

    LSSetItemInfo&
    get_LSSetItemInfo()
    {
        AssertSanity(TLSSetItemInfo);
        return (*(ptr_LSSetItemInfo()));
    }
    const LSSetItemInfo&
    get_LSSetItemInfo() const
    {
        AssertSanity(TLSSetItemInfo);
        return (*(constptr_LSSetItemInfo()));
    }
    operator LSSetItemInfo&()
    {
        return get_LSSetItemInfo();
    }
    operator const LSSetItemInfo&() const
    {
        return get_LSSetItemInfo();
    }

    LSRemoveItemInfo&
    get_LSRemoveItemInfo()
    {
        AssertSanity(TLSRemoveItemInfo);
        return (*(ptr_LSRemoveItemInfo()));
    }
    const LSRemoveItemInfo&
    get_LSRemoveItemInfo() const
    {
        AssertSanity(TLSRemoveItemInfo);
        return (*(constptr_LSRemoveItemInfo()));
    }
    operator LSRemoveItemInfo&()
    {
        return get_LSRemoveItemInfo();
    }
    operator const LSRemoveItemInfo&() const
    {
        return get_LSRemoveItemInfo();
    }

    LSClearInfo&
    get_LSClearInfo()
    {
        AssertSanity(TLSClearInfo);
        return (*(ptr_LSClearInfo()));
    }
    const LSClearInfo&
    get_LSClearInfo() const
    {
        AssertSanity(TLSClearInfo);
        return (*(constptr_LSClearInfo()));
    }
    operator LSClearInfo&()
    {
        return get_LSClearInfo();
    }
    operator const LSClearInfo&() const
    {
        return get_LSClearInfo();
    }

private:
    union {
        LSSetItemInfo mVLSSetItemInfo;
        LSRemoveItemInfo mVLSRemoveItemInfo;
        LSClearInfo mVLSClearInfo;
    };
    Type mType;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::LSWriteInfo>
{
    typedef ::mozilla::dom::LSWriteInfo 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 LSSetItemAndNotifyInfo|
//
namespace mozilla {
namespace dom {
class LSSetItemAndNotifyInfo final
{
private:
    typedef ::nsString nsString;
    typedef ::mozilla::dom::LSValue LSValue;

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

    MOZ_IMPLICIT LSSetItemAndNotifyInfo(
            const nsString& _key,
            const LSValue& _oldValue,
            const LSValue& _value) :
        key_(_key),
        oldValue_(_oldValue),
        value_(_value)
    {
    }

    MOZ_IMPLICIT LSSetItemAndNotifyInfo(
            nsString&& _key,
            LSValue&& _oldValue,
            LSValue&& _value) :
        key_(std::move(_key)),
        oldValue_(std::move(_oldValue)),
        value_(std::move(_value))
    {
    }

    nsString&
    key()
    {
        return key_;
    }
    const nsString&
    key() const
    {
        return key_;
    }

    LSValue&
    oldValue()
    {
        return oldValue_;
    }
    const LSValue&
    oldValue() const
    {
        return oldValue_;
    }

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

private:
    ::mozilla::ipc::IPDLStructMember<nsString> key_;
    ::mozilla::ipc::IPDLStructMember<LSValue> oldValue_;
    ::mozilla::ipc::IPDLStructMember<LSValue> value_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::LSSetItemAndNotifyInfo>
{
    typedef ::mozilla::dom::LSSetItemAndNotifyInfo 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 LSRemoveItemAndNotifyInfo|
//
namespace mozilla {
namespace dom {
class LSRemoveItemAndNotifyInfo final
{
private:
    typedef ::nsString nsString;
    typedef ::mozilla::dom::LSValue LSValue;

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

    MOZ_IMPLICIT LSRemoveItemAndNotifyInfo(
            const nsString& _key,
            const LSValue& _oldValue) :
        key_(_key),
        oldValue_(_oldValue)
    {
    }

    MOZ_IMPLICIT LSRemoveItemAndNotifyInfo(
            nsString&& _key,
            LSValue&& _oldValue) :
        key_(std::move(_key)),
        oldValue_(std::move(_oldValue))
    {
    }

    nsString&
    key()
    {
        return key_;
    }
    const nsString&
    key() const
    {
        return key_;
    }

    LSValue&
    oldValue()
    {
        return oldValue_;
    }
    const LSValue&
    oldValue() const
    {
        return oldValue_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsString> key_;
    ::mozilla::ipc::IPDLStructMember<LSValue> oldValue_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::LSRemoveItemAndNotifyInfo>
{
    typedef ::mozilla::dom::LSRemoveItemAndNotifyInfo 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 LSWriteAndNotifyInfo|
//
namespace mozilla {
namespace dom {
class LSWriteAndNotifyInfo final
{
public:
    enum Type {
        T__None,
        TLSSetItemAndNotifyInfo = 1,
        TLSRemoveItemAndNotifyInfo,
        TLSClearInfo,
        T__Last = TLSClearInfo
    };

private:
    typedef ::mozilla::dom::LSSetItemAndNotifyInfo LSSetItemAndNotifyInfo;
    typedef ::mozilla::dom::LSRemoveItemAndNotifyInfo LSRemoveItemAndNotifyInfo;
    typedef ::mozilla::dom::LSClearInfo LSClearInfo;
    typedef LSSetItemAndNotifyInfo LSSetItemAndNotifyInfo__tdef;
    typedef LSRemoveItemAndNotifyInfo LSRemoveItemAndNotifyInfo__tdef;
    typedef LSClearInfo LSClearInfo__tdef;

    LSSetItemAndNotifyInfo*
    ptr_LSSetItemAndNotifyInfo()
    {
        return (&(mVLSSetItemAndNotifyInfo));
    }
    const LSSetItemAndNotifyInfo*
    constptr_LSSetItemAndNotifyInfo() const
    {
        return (&(mVLSSetItemAndNotifyInfo));
    }
    LSRemoveItemAndNotifyInfo*
    ptr_LSRemoveItemAndNotifyInfo()
    {
        return (&(mVLSRemoveItemAndNotifyInfo));
    }
    const LSRemoveItemAndNotifyInfo*
    constptr_LSRemoveItemAndNotifyInfo() const
    {
        return (&(mVLSRemoveItemAndNotifyInfo));
    }
    LSClearInfo*
    ptr_LSClearInfo()
    {
        return (&(mVLSClearInfo));
    }
    const LSClearInfo*
    constptr_LSClearInfo() const
    {
        return (&(mVLSClearInfo));
    }

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

    MOZ_IMPLICIT LSWriteAndNotifyInfo(const LSSetItemAndNotifyInfo& aOther);

    MOZ_IMPLICIT LSWriteAndNotifyInfo(LSSetItemAndNotifyInfo&& aOther);

    MOZ_IMPLICIT LSWriteAndNotifyInfo(const LSRemoveItemAndNotifyInfo& aOther);

    MOZ_IMPLICIT LSWriteAndNotifyInfo(LSRemoveItemAndNotifyInfo&& aOther);

    MOZ_IMPLICIT LSWriteAndNotifyInfo(const LSClearInfo& aOther);

    MOZ_IMPLICIT LSWriteAndNotifyInfo(LSClearInfo&& aOther);

    MOZ_IMPLICIT LSWriteAndNotifyInfo(const LSWriteAndNotifyInfo& aOther);

    MOZ_IMPLICIT LSWriteAndNotifyInfo(LSWriteAndNotifyInfo&& aOther);

    ~LSWriteAndNotifyInfo();

    Type
    type() const
    {
        return mType;
    }

    LSWriteAndNotifyInfo&
    operator=(const LSSetItemAndNotifyInfo& aRhs);

    LSWriteAndNotifyInfo&
    operator=(LSSetItemAndNotifyInfo&& aRhs);

    LSWriteAndNotifyInfo&
    operator=(const LSRemoveItemAndNotifyInfo& aRhs);

    LSWriteAndNotifyInfo&
    operator=(LSRemoveItemAndNotifyInfo&& aRhs);

    LSWriteAndNotifyInfo&
    operator=(const LSClearInfo& aRhs);

    LSWriteAndNotifyInfo&
    operator=(LSClearInfo&& aRhs);

    LSWriteAndNotifyInfo&
    operator=(const LSWriteAndNotifyInfo& aRhs);

    LSWriteAndNotifyInfo&
    operator=(LSWriteAndNotifyInfo&& aRhs);

    LSSetItemAndNotifyInfo&
    get_LSSetItemAndNotifyInfo()
    {
        AssertSanity(TLSSetItemAndNotifyInfo);
        return (*(ptr_LSSetItemAndNotifyInfo()));
    }
    const LSSetItemAndNotifyInfo&
    get_LSSetItemAndNotifyInfo() const
    {
        AssertSanity(TLSSetItemAndNotifyInfo);
        return (*(constptr_LSSetItemAndNotifyInfo()));
    }
    operator LSSetItemAndNotifyInfo&()
    {
        return get_LSSetItemAndNotifyInfo();
    }
    operator const LSSetItemAndNotifyInfo&() const
    {
        return get_LSSetItemAndNotifyInfo();
    }

    LSRemoveItemAndNotifyInfo&
    get_LSRemoveItemAndNotifyInfo()
    {
        AssertSanity(TLSRemoveItemAndNotifyInfo);
        return (*(ptr_LSRemoveItemAndNotifyInfo()));
    }
    const LSRemoveItemAndNotifyInfo&
    get_LSRemoveItemAndNotifyInfo() const
    {
        AssertSanity(TLSRemoveItemAndNotifyInfo);
        return (*(constptr_LSRemoveItemAndNotifyInfo()));
    }
    operator LSRemoveItemAndNotifyInfo&()
    {
        return get_LSRemoveItemAndNotifyInfo();
    }
    operator const LSRemoveItemAndNotifyInfo&() const
    {
        return get_LSRemoveItemAndNotifyInfo();
    }

    LSClearInfo&
    get_LSClearInfo()
    {
        AssertSanity(TLSClearInfo);
        return (*(ptr_LSClearInfo()));
    }
    const LSClearInfo&
    get_LSClearInfo() const
    {
        AssertSanity(TLSClearInfo);
        return (*(constptr_LSClearInfo()));
    }
    operator LSClearInfo&()
    {
        return get_LSClearInfo();
    }
    operator const LSClearInfo&() const
    {
        return get_LSClearInfo();
    }

private:
    union {
        LSSetItemAndNotifyInfo mVLSSetItemAndNotifyInfo;
        LSRemoveItemAndNotifyInfo mVLSRemoveItemAndNotifyInfo;
        LSClearInfo mVLSClearInfo;
    };
    Type mType;
};
} // namespace dom
} // namespace mozilla

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

namespace mozilla {
namespace dom {
class PBackgroundLSSnapshotParent;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PBackgroundLSSnapshotChild;
} // namespace dom
} // namespace mozilla

//-----------------------------------------------------------------------------
// Code common to PBackgroundLSSnapshotChild and PBackgroundLSSnapshotParent
//
namespace mozilla {
namespace dom {
namespace PBackgroundLSSnapshot {

nsresult
CreateEndpoints(
        mozilla::ipc::EndpointProcInfo aParentDestInfo,
        mozilla::ipc::EndpointProcInfo aChildDestInfo,
        mozilla::ipc::Endpoint<::mozilla::dom::PBackgroundLSSnapshotParent>* aParent,
        mozilla::ipc::Endpoint<::mozilla::dom::PBackgroundLSSnapshotChild>* aChild);

nsresult
CreateEndpoints(
        mozilla::ipc::Endpoint<::mozilla::dom::PBackgroundLSSnapshotParent>* aParent,
        mozilla::ipc::Endpoint<::mozilla::dom::PBackgroundLSSnapshotChild>* aChild);

enum MessageType {
    PBackgroundLSSnapshotStart = PBackgroundLSSnapshotMsgStart << 16,
    Msg_DeleteMe__ID,
    Msg_AsyncCheckpoint__ID,
    Msg_AsyncCheckpointAndNotify__ID,
    Msg_SyncCheckpoint__ID,
    Reply_SyncCheckpoint__ID,
    Msg_SyncCheckpointAndNotify__ID,
    Reply_SyncCheckpointAndNotify__ID,
    Msg_AsyncFinish__ID,
    Msg_SyncFinish__ID,
    Reply_SyncFinish__ID,
    Msg_Loaded__ID,
    Msg_LoadValueAndMoreItems__ID,
    Reply_LoadValueAndMoreItems__ID,
    Msg_LoadKeys__ID,
    Reply_LoadKeys__ID,
    Msg_IncreasePeakUsage__ID,
    Reply_IncreasePeakUsage__ID,
    Msg_MarkDirty__ID,
    Msg___delete____ID,
    Reply___delete____ID,
    PBackgroundLSSnapshotEnd
};

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

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

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

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

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

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

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

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

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

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

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

mozilla::UniquePtr<IPC::Message>
Msg_MarkDirty(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 PBackgroundLSSnapshot
} // namespace dom
} // namespace mozilla

#endif // ifndef PBackgroundLSSnapshot_h
