Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#ifndef PRemoteWorker_h
#define PRemoteWorker_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"
#include "mozilla/dom/ServiceWorkerOpArgs.h"
#include "mozilla/dom/RemoteWorkerTypes.h"
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct RemoteWorkerSuspendOp|
//
namespace mozilla {
namespace dom {
class RemoteWorkerSuspendOp final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
RemoteWorkerSuspendOp() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
private:
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::RemoteWorkerSuspendOp>
{
typedef ::mozilla::dom::RemoteWorkerSuspendOp 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 RemoteWorkerResumeOp|
//
namespace mozilla {
namespace dom {
class RemoteWorkerResumeOp final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
RemoteWorkerResumeOp() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
private:
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::RemoteWorkerResumeOp>
{
typedef ::mozilla::dom::RemoteWorkerResumeOp 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 RemoteWorkerFreezeOp|
//
namespace mozilla {
namespace dom {
class RemoteWorkerFreezeOp final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
RemoteWorkerFreezeOp() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
private:
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::RemoteWorkerFreezeOp>
{
typedef ::mozilla::dom::RemoteWorkerFreezeOp 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 RemoteWorkerThawOp|
//
namespace mozilla {
namespace dom {
class RemoteWorkerThawOp final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
RemoteWorkerThawOp() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
private:
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::RemoteWorkerThawOp>
{
typedef ::mozilla::dom::RemoteWorkerThawOp 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 RemoteWorkerTerminateOp|
//
namespace mozilla {
namespace dom {
class RemoteWorkerTerminateOp final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
RemoteWorkerTerminateOp() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
private:
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::RemoteWorkerTerminateOp>
{
typedef ::mozilla::dom::RemoteWorkerTerminateOp 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 RemoteWorkerPortIdentifierOp|
//
namespace mozilla {
namespace dom {
class RemoteWorkerPortIdentifierOp 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
RemoteWorkerPortIdentifierOp() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT RemoteWorkerPortIdentifierOp(const MessagePortIdentifier& _portIdentifier) :
portIdentifier_(_portIdentifier)
{
}
MOZ_IMPLICIT RemoteWorkerPortIdentifierOp(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::RemoteWorkerPortIdentifierOp>
{
typedef ::mozilla::dom::RemoteWorkerPortIdentifierOp 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 RemoteWorkerAddWindowIDOp|
//
namespace mozilla {
namespace dom {
class RemoteWorkerAddWindowIDOp 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
RemoteWorkerAddWindowIDOp() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT RemoteWorkerAddWindowIDOp(const uint64_t& _windowID) :
windowID_(_windowID)
{
}
MOZ_IMPLICIT RemoteWorkerAddWindowIDOp(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::RemoteWorkerAddWindowIDOp>
{
typedef ::mozilla::dom::RemoteWorkerAddWindowIDOp 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 RemoteWorkerRemoveWindowIDOp|
//
namespace mozilla {
namespace dom {
class RemoteWorkerRemoveWindowIDOp 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
RemoteWorkerRemoveWindowIDOp() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT RemoteWorkerRemoveWindowIDOp(const uint64_t& _windowID) :
windowID_(_windowID)
{
}
MOZ_IMPLICIT RemoteWorkerRemoveWindowIDOp(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::RemoteWorkerRemoveWindowIDOp>
{
typedef ::mozilla::dom::RemoteWorkerRemoveWindowIDOp 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 RemoteWorkerOp|
//
namespace mozilla {
namespace dom {
class RemoteWorkerOp final
{
public:
enum Type {
T__None,
TRemoteWorkerSuspendOp = 1,
TRemoteWorkerResumeOp,
TRemoteWorkerFreezeOp,
TRemoteWorkerThawOp,
TRemoteWorkerTerminateOp,
TRemoteWorkerPortIdentifierOp,
TRemoteWorkerAddWindowIDOp,
TRemoteWorkerRemoveWindowIDOp,
T__Last = TRemoteWorkerRemoveWindowIDOp
};
private:
typedef ::mozilla::dom::RemoteWorkerSuspendOp RemoteWorkerSuspendOp;
typedef ::mozilla::dom::RemoteWorkerResumeOp RemoteWorkerResumeOp;
typedef ::mozilla::dom::RemoteWorkerFreezeOp RemoteWorkerFreezeOp;
typedef ::mozilla::dom::RemoteWorkerThawOp RemoteWorkerThawOp;
typedef ::mozilla::dom::RemoteWorkerTerminateOp RemoteWorkerTerminateOp;
typedef ::mozilla::dom::RemoteWorkerPortIdentifierOp RemoteWorkerPortIdentifierOp;
typedef ::mozilla::dom::RemoteWorkerAddWindowIDOp RemoteWorkerAddWindowIDOp;
typedef ::mozilla::dom::RemoteWorkerRemoveWindowIDOp RemoteWorkerRemoveWindowIDOp;
typedef RemoteWorkerSuspendOp RemoteWorkerSuspendOp__tdef;
typedef RemoteWorkerResumeOp RemoteWorkerResumeOp__tdef;
typedef RemoteWorkerFreezeOp RemoteWorkerFreezeOp__tdef;
typedef RemoteWorkerThawOp RemoteWorkerThawOp__tdef;
typedef RemoteWorkerTerminateOp RemoteWorkerTerminateOp__tdef;
typedef RemoteWorkerPortIdentifierOp RemoteWorkerPortIdentifierOp__tdef;
typedef RemoteWorkerAddWindowIDOp RemoteWorkerAddWindowIDOp__tdef;
typedef RemoteWorkerRemoveWindowIDOp RemoteWorkerRemoveWindowIDOp__tdef;
union Value {
mozilla::AlignedStorage2<RemoteWorkerSuspendOp> VRemoteWorkerSuspendOp;
mozilla::AlignedStorage2<RemoteWorkerResumeOp> VRemoteWorkerResumeOp;
mozilla::AlignedStorage2<RemoteWorkerFreezeOp> VRemoteWorkerFreezeOp;
mozilla::AlignedStorage2<RemoteWorkerThawOp> VRemoteWorkerThawOp;
mozilla::AlignedStorage2<RemoteWorkerTerminateOp> VRemoteWorkerTerminateOp;
mozilla::AlignedStorage2<RemoteWorkerPortIdentifierOp> VRemoteWorkerPortIdentifierOp;
mozilla::AlignedStorage2<RemoteWorkerAddWindowIDOp> VRemoteWorkerAddWindowIDOp;
mozilla::AlignedStorage2<RemoteWorkerRemoveWindowIDOp> VRemoteWorkerRemoveWindowIDOp;
};
RemoteWorkerSuspendOp*
ptr_RemoteWorkerSuspendOp()
{
return ((mValue).VRemoteWorkerSuspendOp).addr();
}
const RemoteWorkerSuspendOp*
constptr_RemoteWorkerSuspendOp() const
{
return ((mValue).VRemoteWorkerSuspendOp).addr();
}
RemoteWorkerResumeOp*
ptr_RemoteWorkerResumeOp()
{
return ((mValue).VRemoteWorkerResumeOp).addr();
}
const RemoteWorkerResumeOp*
constptr_RemoteWorkerResumeOp() const
{
return ((mValue).VRemoteWorkerResumeOp).addr();
}
RemoteWorkerFreezeOp*
ptr_RemoteWorkerFreezeOp()
{
return ((mValue).VRemoteWorkerFreezeOp).addr();
}
const RemoteWorkerFreezeOp*
constptr_RemoteWorkerFreezeOp() const
{
return ((mValue).VRemoteWorkerFreezeOp).addr();
}
RemoteWorkerThawOp*
ptr_RemoteWorkerThawOp()
{
return ((mValue).VRemoteWorkerThawOp).addr();
}
const RemoteWorkerThawOp*
constptr_RemoteWorkerThawOp() const
{
return ((mValue).VRemoteWorkerThawOp).addr();
}
RemoteWorkerTerminateOp*
ptr_RemoteWorkerTerminateOp()
{
return ((mValue).VRemoteWorkerTerminateOp).addr();
}
const RemoteWorkerTerminateOp*
constptr_RemoteWorkerTerminateOp() const
{
return ((mValue).VRemoteWorkerTerminateOp).addr();
}
RemoteWorkerPortIdentifierOp*
ptr_RemoteWorkerPortIdentifierOp()
{
return ((mValue).VRemoteWorkerPortIdentifierOp).addr();
}
const RemoteWorkerPortIdentifierOp*
constptr_RemoteWorkerPortIdentifierOp() const
{
return ((mValue).VRemoteWorkerPortIdentifierOp).addr();
}
RemoteWorkerAddWindowIDOp*
ptr_RemoteWorkerAddWindowIDOp()
{
return ((mValue).VRemoteWorkerAddWindowIDOp).addr();
}
const RemoteWorkerAddWindowIDOp*
constptr_RemoteWorkerAddWindowIDOp() const
{
return ((mValue).VRemoteWorkerAddWindowIDOp).addr();
}
RemoteWorkerRemoveWindowIDOp*
ptr_RemoteWorkerRemoveWindowIDOp()
{
return ((mValue).VRemoteWorkerRemoveWindowIDOp).addr();
}
const RemoteWorkerRemoveWindowIDOp*
constptr_RemoteWorkerRemoveWindowIDOp() const
{
return ((mValue).VRemoteWorkerRemoveWindowIDOp).addr();
}
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 RemoteWorkerOp() :
mType(T__None)
{
}
MOZ_IMPLICIT RemoteWorkerOp(const RemoteWorkerSuspendOp& aOther);
MOZ_IMPLICIT RemoteWorkerOp(RemoteWorkerSuspendOp&& aOther);
MOZ_IMPLICIT RemoteWorkerOp(const RemoteWorkerResumeOp& aOther);
MOZ_IMPLICIT RemoteWorkerOp(RemoteWorkerResumeOp&& aOther);
MOZ_IMPLICIT RemoteWorkerOp(const RemoteWorkerFreezeOp& aOther);
MOZ_IMPLICIT RemoteWorkerOp(RemoteWorkerFreezeOp&& aOther);
MOZ_IMPLICIT RemoteWorkerOp(const RemoteWorkerThawOp& aOther);
MOZ_IMPLICIT RemoteWorkerOp(RemoteWorkerThawOp&& aOther);
MOZ_IMPLICIT RemoteWorkerOp(const RemoteWorkerTerminateOp& aOther);
MOZ_IMPLICIT RemoteWorkerOp(RemoteWorkerTerminateOp&& aOther);
MOZ_IMPLICIT RemoteWorkerOp(const RemoteWorkerPortIdentifierOp& aOther);
MOZ_IMPLICIT RemoteWorkerOp(RemoteWorkerPortIdentifierOp&& aOther);
MOZ_IMPLICIT RemoteWorkerOp(const RemoteWorkerAddWindowIDOp& aOther);
MOZ_IMPLICIT RemoteWorkerOp(RemoteWorkerAddWindowIDOp&& aOther);
MOZ_IMPLICIT RemoteWorkerOp(const RemoteWorkerRemoveWindowIDOp& aOther);
MOZ_IMPLICIT RemoteWorkerOp(RemoteWorkerRemoveWindowIDOp&& aOther);
MOZ_IMPLICIT RemoteWorkerOp(const RemoteWorkerOp& aOther);
MOZ_IMPLICIT RemoteWorkerOp(RemoteWorkerOp&& aOther);
~RemoteWorkerOp();
Type
type() const
{
return mType;
}
RemoteWorkerOp&
operator=(const RemoteWorkerSuspendOp& aRhs);
RemoteWorkerOp&
operator=(RemoteWorkerSuspendOp&& aRhs);
RemoteWorkerOp&
operator=(const RemoteWorkerResumeOp& aRhs);
RemoteWorkerOp&
operator=(RemoteWorkerResumeOp&& aRhs);
RemoteWorkerOp&
operator=(const RemoteWorkerFreezeOp& aRhs);
RemoteWorkerOp&
operator=(RemoteWorkerFreezeOp&& aRhs);
RemoteWorkerOp&
operator=(const RemoteWorkerThawOp& aRhs);
RemoteWorkerOp&
operator=(RemoteWorkerThawOp&& aRhs);
RemoteWorkerOp&
operator=(const RemoteWorkerTerminateOp& aRhs);
RemoteWorkerOp&
operator=(RemoteWorkerTerminateOp&& aRhs);
RemoteWorkerOp&
operator=(const RemoteWorkerPortIdentifierOp& aRhs);
RemoteWorkerOp&
operator=(RemoteWorkerPortIdentifierOp&& aRhs);
RemoteWorkerOp&
operator=(const RemoteWorkerAddWindowIDOp& aRhs);
RemoteWorkerOp&
operator=(RemoteWorkerAddWindowIDOp&& aRhs);
RemoteWorkerOp&
operator=(const RemoteWorkerRemoveWindowIDOp& aRhs);
RemoteWorkerOp&
operator=(RemoteWorkerRemoveWindowIDOp&& aRhs);
RemoteWorkerOp&
operator=(const RemoteWorkerOp& aRhs);
RemoteWorkerOp&
operator=(RemoteWorkerOp&& aRhs);
RemoteWorkerSuspendOp&
get_RemoteWorkerSuspendOp()
{
AssertSanity(TRemoteWorkerSuspendOp);
return (*(ptr_RemoteWorkerSuspendOp()));
}
const RemoteWorkerSuspendOp&
get_RemoteWorkerSuspendOp() const
{
AssertSanity(TRemoteWorkerSuspendOp);
return (*(constptr_RemoteWorkerSuspendOp()));
}
operator RemoteWorkerSuspendOp&()
{
return get_RemoteWorkerSuspendOp();
}
operator const RemoteWorkerSuspendOp&() const
{
return get_RemoteWorkerSuspendOp();
}
RemoteWorkerResumeOp&
get_RemoteWorkerResumeOp()
{
AssertSanity(TRemoteWorkerResumeOp);
return (*(ptr_RemoteWorkerResumeOp()));
}
const RemoteWorkerResumeOp&
get_RemoteWorkerResumeOp() const
{
AssertSanity(TRemoteWorkerResumeOp);
return (*(constptr_RemoteWorkerResumeOp()));
}
operator RemoteWorkerResumeOp&()
{
return get_RemoteWorkerResumeOp();
}
operator const RemoteWorkerResumeOp&() const
{
return get_RemoteWorkerResumeOp();
}
RemoteWorkerFreezeOp&
get_RemoteWorkerFreezeOp()
{
AssertSanity(TRemoteWorkerFreezeOp);
return (*(ptr_RemoteWorkerFreezeOp()));
}
const RemoteWorkerFreezeOp&
get_RemoteWorkerFreezeOp() const
{
AssertSanity(TRemoteWorkerFreezeOp);
return (*(constptr_RemoteWorkerFreezeOp()));
}
operator RemoteWorkerFreezeOp&()
{
return get_RemoteWorkerFreezeOp();
}
operator const RemoteWorkerFreezeOp&() const
{
return get_RemoteWorkerFreezeOp();
}
RemoteWorkerThawOp&
get_RemoteWorkerThawOp()
{
AssertSanity(TRemoteWorkerThawOp);
return (*(ptr_RemoteWorkerThawOp()));
}
const RemoteWorkerThawOp&
get_RemoteWorkerThawOp() const
{
AssertSanity(TRemoteWorkerThawOp);
return (*(constptr_RemoteWorkerThawOp()));
}
operator RemoteWorkerThawOp&()
{
return get_RemoteWorkerThawOp();
}
operator const RemoteWorkerThawOp&() const
{
return get_RemoteWorkerThawOp();
}
RemoteWorkerTerminateOp&
get_RemoteWorkerTerminateOp()
{
AssertSanity(TRemoteWorkerTerminateOp);
return (*(ptr_RemoteWorkerTerminateOp()));
}
const RemoteWorkerTerminateOp&
get_RemoteWorkerTerminateOp() const
{
AssertSanity(TRemoteWorkerTerminateOp);
return (*(constptr_RemoteWorkerTerminateOp()));
}
operator RemoteWorkerTerminateOp&()
{
return get_RemoteWorkerTerminateOp();
}
operator const RemoteWorkerTerminateOp&() const
{
return get_RemoteWorkerTerminateOp();
}
RemoteWorkerPortIdentifierOp&
get_RemoteWorkerPortIdentifierOp()
{
AssertSanity(TRemoteWorkerPortIdentifierOp);
return (*(ptr_RemoteWorkerPortIdentifierOp()));
}
const RemoteWorkerPortIdentifierOp&
get_RemoteWorkerPortIdentifierOp() const
{
AssertSanity(TRemoteWorkerPortIdentifierOp);
return (*(constptr_RemoteWorkerPortIdentifierOp()));
}
operator RemoteWorkerPortIdentifierOp&()
{
return get_RemoteWorkerPortIdentifierOp();
}
operator const RemoteWorkerPortIdentifierOp&() const
{
return get_RemoteWorkerPortIdentifierOp();
}
RemoteWorkerAddWindowIDOp&
get_RemoteWorkerAddWindowIDOp()
{
AssertSanity(TRemoteWorkerAddWindowIDOp);
return (*(ptr_RemoteWorkerAddWindowIDOp()));
}
const RemoteWorkerAddWindowIDOp&
get_RemoteWorkerAddWindowIDOp() const
{
AssertSanity(TRemoteWorkerAddWindowIDOp);
return (*(constptr_RemoteWorkerAddWindowIDOp()));
}
operator RemoteWorkerAddWindowIDOp&()
{
return get_RemoteWorkerAddWindowIDOp();
}
operator const RemoteWorkerAddWindowIDOp&() const
{
return get_RemoteWorkerAddWindowIDOp();
}
RemoteWorkerRemoveWindowIDOp&
get_RemoteWorkerRemoveWindowIDOp()
{
AssertSanity(TRemoteWorkerRemoveWindowIDOp);
return (*(ptr_RemoteWorkerRemoveWindowIDOp()));
}
const RemoteWorkerRemoveWindowIDOp&
get_RemoteWorkerRemoveWindowIDOp() const
{
AssertSanity(TRemoteWorkerRemoveWindowIDOp);
return (*(constptr_RemoteWorkerRemoveWindowIDOp()));
}
operator RemoteWorkerRemoveWindowIDOp&()
{
return get_RemoteWorkerRemoveWindowIDOp();
}
operator const RemoteWorkerRemoveWindowIDOp&() const
{
return get_RemoteWorkerRemoveWindowIDOp();
}
private:
Value mValue;
Type mType;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::RemoteWorkerOp>
{
typedef ::mozilla::dom::RemoteWorkerOp 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 PRemoteWorkerParent;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PRemoteWorkerChild;
} // namespace dom
} // namespace mozilla
//-----------------------------------------------------------------------------
// Code common to PRemoteWorkerChild and PRemoteWorkerParent
//
namespace mozilla {
namespace dom {
namespace PRemoteWorker {
nsresult
CreateEndpoints(
base::ProcessId aParentDestPid,
base::ProcessId aChildDestPid,
mozilla::ipc::Endpoint<::mozilla::dom::PRemoteWorkerParent>* aParent,
mozilla::ipc::Endpoint<::mozilla::dom::PRemoteWorkerChild>* aChild);
enum MessageType {
PRemoteWorkerStart = PRemoteWorkerMsgStart << 16,
Msg_Created__ID,
Msg_Error__ID,
Msg_NotifyLock__ID,
Msg_NotifyWebTransport__ID,
Msg_Close__ID,
Msg_SetServiceWorkerSkipWaitingFlag__ID,
Reply_SetServiceWorkerSkipWaitingFlag__ID,
Msg_PFetchEventOpProxyConstructor__ID,
Reply_PFetchEventOpProxyConstructor__ID,
Msg___delete____ID,
Reply___delete____ID,
Msg_ExecOp__ID,
Msg_ExecServiceWorkerOp__ID,
Reply_ExecServiceWorkerOp__ID,
PRemoteWorkerEnd
};
mozilla::UniquePtr<IPC::Message>
Msg_Created(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_Error(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_NotifyLock(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_NotifyWebTransport(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_Close(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_SetServiceWorkerSkipWaitingFlag(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_SetServiceWorkerSkipWaitingFlag(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_PFetchEventOpProxyConstructor(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_PFetchEventOpProxyConstructor(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg___delete__(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply___delete__(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_ExecOp(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_ExecServiceWorkerOp(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_ExecServiceWorkerOp(int32_t routingId);
} // namespace PRemoteWorker
} // namespace dom
} // namespace mozilla
#endif // ifndef PRemoteWorker_h