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

#ifndef SharedWorkerOpArgs_h
#define SharedWorkerOpArgs_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/ipc/IPDLStructMember.h"
#include "mozilla/dom/DOMTypes.h"


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct SharedWorkerSuspendOpArgs|
//
namespace mozilla {
namespace dom {
class SharedWorkerSuspendOpArgs final
{
private:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::SharedWorkerTerminateOpArgs>
{
    typedef ::mozilla::dom::SharedWorkerTerminateOpArgs 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 SharedWorkerPortIdentifierOpArgs|
//
namespace mozilla {
namespace dom {
class SharedWorkerPortIdentifierOpArgs final
{
private:
    typedef ::mozilla::dom::MessagePortIdentifier MessagePortIdentifier;

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

    MOZ_IMPLICIT SharedWorkerPortIdentifierOpArgs(const MessagePortIdentifier& _portIdentifier) :
        portIdentifier_(_portIdentifier)
    {
    }

    MOZ_IMPLICIT SharedWorkerPortIdentifierOpArgs(MessagePortIdentifier&& _portIdentifier) :
        portIdentifier_(std::move(_portIdentifier))
    {
    }

    MessagePortIdentifier&
    portIdentifier()
    {
        return portIdentifier_;
    }
    const MessagePortIdentifier&
    portIdentifier() const
    {
        return portIdentifier_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<MessagePortIdentifier> portIdentifier_;
};
} // namespace dom
} // namespace mozilla

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

    MOZ_IMPLICIT SharedWorkerAddWindowIDOpArgs(const uint64_t& _windowID) :
        windowID_(_windowID)
    {
    }

    MOZ_IMPLICIT SharedWorkerAddWindowIDOpArgs(uint64_t&& _windowID) :
        windowID_(std::move(_windowID))
    {
    }

    uint64_t&
    windowID()
    {
        return windowID_;
    }
    const uint64_t&
    windowID() const
    {
        return windowID_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<uint64_t> windowID_;
};
} // namespace dom
} // namespace mozilla

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

    MOZ_IMPLICIT SharedWorkerRemoveWindowIDOpArgs(const uint64_t& _windowID) :
        windowID_(_windowID)
    {
    }

    MOZ_IMPLICIT SharedWorkerRemoveWindowIDOpArgs(uint64_t&& _windowID) :
        windowID_(std::move(_windowID))
    {
    }

    uint64_t&
    windowID()
    {
        return windowID_;
    }
    const uint64_t&
    windowID() const
    {
        return windowID_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<uint64_t> windowID_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::SharedWorkerRemoveWindowIDOpArgs>
{
    typedef ::mozilla::dom::SharedWorkerRemoveWindowIDOpArgs 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 SharedWorkerOpArgs|
//
namespace mozilla {
namespace dom {
class SharedWorkerOpArgs final
{
public:
    enum Type {
        T__None,
        TSharedWorkerSuspendOpArgs = 1,
        TSharedWorkerResumeOpArgs,
        TSharedWorkerFreezeOpArgs,
        TSharedWorkerThawOpArgs,
        TSharedWorkerTerminateOpArgs,
        TSharedWorkerPortIdentifierOpArgs,
        TSharedWorkerAddWindowIDOpArgs,
        TSharedWorkerRemoveWindowIDOpArgs,
        T__Last = TSharedWorkerRemoveWindowIDOpArgs
    };

private:
    typedef ::mozilla::dom::SharedWorkerSuspendOpArgs SharedWorkerSuspendOpArgs;
    typedef ::mozilla::dom::SharedWorkerResumeOpArgs SharedWorkerResumeOpArgs;
    typedef ::mozilla::dom::SharedWorkerFreezeOpArgs SharedWorkerFreezeOpArgs;
    typedef ::mozilla::dom::SharedWorkerThawOpArgs SharedWorkerThawOpArgs;
    typedef ::mozilla::dom::SharedWorkerTerminateOpArgs SharedWorkerTerminateOpArgs;
    typedef ::mozilla::dom::SharedWorkerPortIdentifierOpArgs SharedWorkerPortIdentifierOpArgs;
    typedef ::mozilla::dom::SharedWorkerAddWindowIDOpArgs SharedWorkerAddWindowIDOpArgs;
    typedef ::mozilla::dom::SharedWorkerRemoveWindowIDOpArgs SharedWorkerRemoveWindowIDOpArgs;
    typedef SharedWorkerSuspendOpArgs SharedWorkerSuspendOpArgs__tdef;
    typedef SharedWorkerResumeOpArgs SharedWorkerResumeOpArgs__tdef;
    typedef SharedWorkerFreezeOpArgs SharedWorkerFreezeOpArgs__tdef;
    typedef SharedWorkerThawOpArgs SharedWorkerThawOpArgs__tdef;
    typedef SharedWorkerTerminateOpArgs SharedWorkerTerminateOpArgs__tdef;
    typedef SharedWorkerPortIdentifierOpArgs SharedWorkerPortIdentifierOpArgs__tdef;
    typedef SharedWorkerAddWindowIDOpArgs SharedWorkerAddWindowIDOpArgs__tdef;
    typedef SharedWorkerRemoveWindowIDOpArgs SharedWorkerRemoveWindowIDOpArgs__tdef;

    SharedWorkerSuspendOpArgs*
    ptr_SharedWorkerSuspendOpArgs()
    {
        return (&(mVSharedWorkerSuspendOpArgs));
    }
    const SharedWorkerSuspendOpArgs*
    constptr_SharedWorkerSuspendOpArgs() const
    {
        return (&(mVSharedWorkerSuspendOpArgs));
    }
    SharedWorkerResumeOpArgs*
    ptr_SharedWorkerResumeOpArgs()
    {
        return (&(mVSharedWorkerResumeOpArgs));
    }
    const SharedWorkerResumeOpArgs*
    constptr_SharedWorkerResumeOpArgs() const
    {
        return (&(mVSharedWorkerResumeOpArgs));
    }
    SharedWorkerFreezeOpArgs*
    ptr_SharedWorkerFreezeOpArgs()
    {
        return (&(mVSharedWorkerFreezeOpArgs));
    }
    const SharedWorkerFreezeOpArgs*
    constptr_SharedWorkerFreezeOpArgs() const
    {
        return (&(mVSharedWorkerFreezeOpArgs));
    }
    SharedWorkerThawOpArgs*
    ptr_SharedWorkerThawOpArgs()
    {
        return (&(mVSharedWorkerThawOpArgs));
    }
    const SharedWorkerThawOpArgs*
    constptr_SharedWorkerThawOpArgs() const
    {
        return (&(mVSharedWorkerThawOpArgs));
    }
    SharedWorkerTerminateOpArgs*
    ptr_SharedWorkerTerminateOpArgs()
    {
        return (&(mVSharedWorkerTerminateOpArgs));
    }
    const SharedWorkerTerminateOpArgs*
    constptr_SharedWorkerTerminateOpArgs() const
    {
        return (&(mVSharedWorkerTerminateOpArgs));
    }
    SharedWorkerPortIdentifierOpArgs*
    ptr_SharedWorkerPortIdentifierOpArgs()
    {
        return (&(mVSharedWorkerPortIdentifierOpArgs));
    }
    const SharedWorkerPortIdentifierOpArgs*
    constptr_SharedWorkerPortIdentifierOpArgs() const
    {
        return (&(mVSharedWorkerPortIdentifierOpArgs));
    }
    SharedWorkerAddWindowIDOpArgs*
    ptr_SharedWorkerAddWindowIDOpArgs()
    {
        return (&(mVSharedWorkerAddWindowIDOpArgs));
    }
    const SharedWorkerAddWindowIDOpArgs*
    constptr_SharedWorkerAddWindowIDOpArgs() const
    {
        return (&(mVSharedWorkerAddWindowIDOpArgs));
    }
    SharedWorkerRemoveWindowIDOpArgs*
    ptr_SharedWorkerRemoveWindowIDOpArgs()
    {
        return (&(mVSharedWorkerRemoveWindowIDOpArgs));
    }
    const SharedWorkerRemoveWindowIDOpArgs*
    constptr_SharedWorkerRemoveWindowIDOpArgs() const
    {
        return (&(mVSharedWorkerRemoveWindowIDOpArgs));
    }

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

    MOZ_IMPLICIT SharedWorkerOpArgs(const SharedWorkerSuspendOpArgs& aOther);

    MOZ_IMPLICIT SharedWorkerOpArgs(SharedWorkerSuspendOpArgs&& aOther);

    MOZ_IMPLICIT SharedWorkerOpArgs(const SharedWorkerResumeOpArgs& aOther);

    MOZ_IMPLICIT SharedWorkerOpArgs(SharedWorkerResumeOpArgs&& aOther);

    MOZ_IMPLICIT SharedWorkerOpArgs(const SharedWorkerFreezeOpArgs& aOther);

    MOZ_IMPLICIT SharedWorkerOpArgs(SharedWorkerFreezeOpArgs&& aOther);

    MOZ_IMPLICIT SharedWorkerOpArgs(const SharedWorkerThawOpArgs& aOther);

    MOZ_IMPLICIT SharedWorkerOpArgs(SharedWorkerThawOpArgs&& aOther);

    MOZ_IMPLICIT SharedWorkerOpArgs(const SharedWorkerTerminateOpArgs& aOther);

    MOZ_IMPLICIT SharedWorkerOpArgs(SharedWorkerTerminateOpArgs&& aOther);

    MOZ_IMPLICIT SharedWorkerOpArgs(const SharedWorkerPortIdentifierOpArgs& aOther);

    MOZ_IMPLICIT SharedWorkerOpArgs(SharedWorkerPortIdentifierOpArgs&& aOther);

    MOZ_IMPLICIT SharedWorkerOpArgs(const SharedWorkerAddWindowIDOpArgs& aOther);

    MOZ_IMPLICIT SharedWorkerOpArgs(SharedWorkerAddWindowIDOpArgs&& aOther);

    MOZ_IMPLICIT SharedWorkerOpArgs(const SharedWorkerRemoveWindowIDOpArgs& aOther);

    MOZ_IMPLICIT SharedWorkerOpArgs(SharedWorkerRemoveWindowIDOpArgs&& aOther);

    MOZ_IMPLICIT SharedWorkerOpArgs(const SharedWorkerOpArgs& aOther);

    MOZ_IMPLICIT SharedWorkerOpArgs(SharedWorkerOpArgs&& aOther);

    ~SharedWorkerOpArgs();

    Type
    type() const
    {
        return mType;
    }

    SharedWorkerOpArgs&
    operator=(const SharedWorkerSuspendOpArgs& aRhs);

    SharedWorkerOpArgs&
    operator=(SharedWorkerSuspendOpArgs&& aRhs);

    SharedWorkerOpArgs&
    operator=(const SharedWorkerResumeOpArgs& aRhs);

    SharedWorkerOpArgs&
    operator=(SharedWorkerResumeOpArgs&& aRhs);

    SharedWorkerOpArgs&
    operator=(const SharedWorkerFreezeOpArgs& aRhs);

    SharedWorkerOpArgs&
    operator=(SharedWorkerFreezeOpArgs&& aRhs);

    SharedWorkerOpArgs&
    operator=(const SharedWorkerThawOpArgs& aRhs);

    SharedWorkerOpArgs&
    operator=(SharedWorkerThawOpArgs&& aRhs);

    SharedWorkerOpArgs&
    operator=(const SharedWorkerTerminateOpArgs& aRhs);

    SharedWorkerOpArgs&
    operator=(SharedWorkerTerminateOpArgs&& aRhs);

    SharedWorkerOpArgs&
    operator=(const SharedWorkerPortIdentifierOpArgs& aRhs);

    SharedWorkerOpArgs&
    operator=(SharedWorkerPortIdentifierOpArgs&& aRhs);

    SharedWorkerOpArgs&
    operator=(const SharedWorkerAddWindowIDOpArgs& aRhs);

    SharedWorkerOpArgs&
    operator=(SharedWorkerAddWindowIDOpArgs&& aRhs);

    SharedWorkerOpArgs&
    operator=(const SharedWorkerRemoveWindowIDOpArgs& aRhs);

    SharedWorkerOpArgs&
    operator=(SharedWorkerRemoveWindowIDOpArgs&& aRhs);

    SharedWorkerOpArgs&
    operator=(const SharedWorkerOpArgs& aRhs);

    SharedWorkerOpArgs&
    operator=(SharedWorkerOpArgs&& aRhs);

    SharedWorkerSuspendOpArgs&
    get_SharedWorkerSuspendOpArgs()
    {
        AssertSanity(TSharedWorkerSuspendOpArgs);
        return (*(ptr_SharedWorkerSuspendOpArgs()));
    }
    const SharedWorkerSuspendOpArgs&
    get_SharedWorkerSuspendOpArgs() const
    {
        AssertSanity(TSharedWorkerSuspendOpArgs);
        return (*(constptr_SharedWorkerSuspendOpArgs()));
    }
    operator SharedWorkerSuspendOpArgs&()
    {
        return get_SharedWorkerSuspendOpArgs();
    }
    operator const SharedWorkerSuspendOpArgs&() const
    {
        return get_SharedWorkerSuspendOpArgs();
    }

    SharedWorkerResumeOpArgs&
    get_SharedWorkerResumeOpArgs()
    {
        AssertSanity(TSharedWorkerResumeOpArgs);
        return (*(ptr_SharedWorkerResumeOpArgs()));
    }
    const SharedWorkerResumeOpArgs&
    get_SharedWorkerResumeOpArgs() const
    {
        AssertSanity(TSharedWorkerResumeOpArgs);
        return (*(constptr_SharedWorkerResumeOpArgs()));
    }
    operator SharedWorkerResumeOpArgs&()
    {
        return get_SharedWorkerResumeOpArgs();
    }
    operator const SharedWorkerResumeOpArgs&() const
    {
        return get_SharedWorkerResumeOpArgs();
    }

    SharedWorkerFreezeOpArgs&
    get_SharedWorkerFreezeOpArgs()
    {
        AssertSanity(TSharedWorkerFreezeOpArgs);
        return (*(ptr_SharedWorkerFreezeOpArgs()));
    }
    const SharedWorkerFreezeOpArgs&
    get_SharedWorkerFreezeOpArgs() const
    {
        AssertSanity(TSharedWorkerFreezeOpArgs);
        return (*(constptr_SharedWorkerFreezeOpArgs()));
    }
    operator SharedWorkerFreezeOpArgs&()
    {
        return get_SharedWorkerFreezeOpArgs();
    }
    operator const SharedWorkerFreezeOpArgs&() const
    {
        return get_SharedWorkerFreezeOpArgs();
    }

    SharedWorkerThawOpArgs&
    get_SharedWorkerThawOpArgs()
    {
        AssertSanity(TSharedWorkerThawOpArgs);
        return (*(ptr_SharedWorkerThawOpArgs()));
    }
    const SharedWorkerThawOpArgs&
    get_SharedWorkerThawOpArgs() const
    {
        AssertSanity(TSharedWorkerThawOpArgs);
        return (*(constptr_SharedWorkerThawOpArgs()));
    }
    operator SharedWorkerThawOpArgs&()
    {
        return get_SharedWorkerThawOpArgs();
    }
    operator const SharedWorkerThawOpArgs&() const
    {
        return get_SharedWorkerThawOpArgs();
    }

    SharedWorkerTerminateOpArgs&
    get_SharedWorkerTerminateOpArgs()
    {
        AssertSanity(TSharedWorkerTerminateOpArgs);
        return (*(ptr_SharedWorkerTerminateOpArgs()));
    }
    const SharedWorkerTerminateOpArgs&
    get_SharedWorkerTerminateOpArgs() const
    {
        AssertSanity(TSharedWorkerTerminateOpArgs);
        return (*(constptr_SharedWorkerTerminateOpArgs()));
    }
    operator SharedWorkerTerminateOpArgs&()
    {
        return get_SharedWorkerTerminateOpArgs();
    }
    operator const SharedWorkerTerminateOpArgs&() const
    {
        return get_SharedWorkerTerminateOpArgs();
    }

    SharedWorkerPortIdentifierOpArgs&
    get_SharedWorkerPortIdentifierOpArgs()
    {
        AssertSanity(TSharedWorkerPortIdentifierOpArgs);
        return (*(ptr_SharedWorkerPortIdentifierOpArgs()));
    }
    const SharedWorkerPortIdentifierOpArgs&
    get_SharedWorkerPortIdentifierOpArgs() const
    {
        AssertSanity(TSharedWorkerPortIdentifierOpArgs);
        return (*(constptr_SharedWorkerPortIdentifierOpArgs()));
    }
    operator SharedWorkerPortIdentifierOpArgs&()
    {
        return get_SharedWorkerPortIdentifierOpArgs();
    }
    operator const SharedWorkerPortIdentifierOpArgs&() const
    {
        return get_SharedWorkerPortIdentifierOpArgs();
    }

    SharedWorkerAddWindowIDOpArgs&
    get_SharedWorkerAddWindowIDOpArgs()
    {
        AssertSanity(TSharedWorkerAddWindowIDOpArgs);
        return (*(ptr_SharedWorkerAddWindowIDOpArgs()));
    }
    const SharedWorkerAddWindowIDOpArgs&
    get_SharedWorkerAddWindowIDOpArgs() const
    {
        AssertSanity(TSharedWorkerAddWindowIDOpArgs);
        return (*(constptr_SharedWorkerAddWindowIDOpArgs()));
    }
    operator SharedWorkerAddWindowIDOpArgs&()
    {
        return get_SharedWorkerAddWindowIDOpArgs();
    }
    operator const SharedWorkerAddWindowIDOpArgs&() const
    {
        return get_SharedWorkerAddWindowIDOpArgs();
    }

    SharedWorkerRemoveWindowIDOpArgs&
    get_SharedWorkerRemoveWindowIDOpArgs()
    {
        AssertSanity(TSharedWorkerRemoveWindowIDOpArgs);
        return (*(ptr_SharedWorkerRemoveWindowIDOpArgs()));
    }
    const SharedWorkerRemoveWindowIDOpArgs&
    get_SharedWorkerRemoveWindowIDOpArgs() const
    {
        AssertSanity(TSharedWorkerRemoveWindowIDOpArgs);
        return (*(constptr_SharedWorkerRemoveWindowIDOpArgs()));
    }
    operator SharedWorkerRemoveWindowIDOpArgs&()
    {
        return get_SharedWorkerRemoveWindowIDOpArgs();
    }
    operator const SharedWorkerRemoveWindowIDOpArgs&() const
    {
        return get_SharedWorkerRemoveWindowIDOpArgs();
    }

private:
    union {
        SharedWorkerSuspendOpArgs mVSharedWorkerSuspendOpArgs;
        SharedWorkerResumeOpArgs mVSharedWorkerResumeOpArgs;
        SharedWorkerFreezeOpArgs mVSharedWorkerFreezeOpArgs;
        SharedWorkerThawOpArgs mVSharedWorkerThawOpArgs;
        SharedWorkerTerminateOpArgs mVSharedWorkerTerminateOpArgs;
        SharedWorkerPortIdentifierOpArgs mVSharedWorkerPortIdentifierOpArgs;
        SharedWorkerAddWindowIDOpArgs mVSharedWorkerAddWindowIDOpArgs;
        SharedWorkerRemoveWindowIDOpArgs mVSharedWorkerRemoveWindowIDOpArgs;
    };
    Type mType;
};
} // namespace dom
} // namespace mozilla

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

#endif // ifndef SharedWorkerOpArgs_h
