Copy as Markdown
Other Tools
//
// 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