Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#ifndef PWebIdentity_h
#define PWebIdentity_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"
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct IPCIdentityCredential|
//
namespace mozilla {
namespace dom {
class IPCIdentityCredential 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
IPCIdentityCredential() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT IPCIdentityCredential(
const nsString& _id,
const mozilla::Maybe<nsString>& _token) :
id_(_id),
token_(_token)
{
}
MOZ_IMPLICIT IPCIdentityCredential(
nsString&& _id,
mozilla::Maybe<nsString>&& _token) :
id_(std::move(_id)),
token_(std::move(_token))
{
}
nsString&
id()
{
return id_;
}
const nsString&
id() const
{
return id_;
}
mozilla::Maybe<nsString>&
token()
{
return token_;
}
const mozilla::Maybe<nsString>&
token() const
{
return token_;
}
private:
::mozilla::ipc::IPDLStructMember<nsString> id_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsString>> token_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCIdentityCredential>
{
typedef ::mozilla::dom::IPCIdentityCredential 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 WebIdentityGetCredentialResponse|
//
namespace mozilla {
namespace dom {
class WebIdentityGetCredentialResponse final
{
public:
enum Type {
T__None,
Tnsresult = 1,
TIPCIdentityCredential,
T__Last = TIPCIdentityCredential
};
private:
typedef ::nsresult nsresult;
typedef ::mozilla::dom::IPCIdentityCredential IPCIdentityCredential;
typedef nsresult nsresult__tdef;
typedef IPCIdentityCredential IPCIdentityCredential__tdef;
nsresult*
ptr_nsresult()
{
return (&(mVnsresult));
}
const nsresult*
constptr_nsresult() const
{
return (&(mVnsresult));
}
IPCIdentityCredential*
ptr_IPCIdentityCredential()
{
return (&(mVIPCIdentityCredential));
}
const IPCIdentityCredential*
constptr_IPCIdentityCredential() const
{
return (&(mVIPCIdentityCredential));
}
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 WebIdentityGetCredentialResponse() :
mType(T__None)
{
}
MOZ_IMPLICIT WebIdentityGetCredentialResponse(const nsresult& aOther);
MOZ_IMPLICIT WebIdentityGetCredentialResponse(nsresult&& aOther);
MOZ_IMPLICIT WebIdentityGetCredentialResponse(const IPCIdentityCredential& aOther);
MOZ_IMPLICIT WebIdentityGetCredentialResponse(IPCIdentityCredential&& aOther);
MOZ_IMPLICIT WebIdentityGetCredentialResponse(const WebIdentityGetCredentialResponse& aOther);
MOZ_IMPLICIT WebIdentityGetCredentialResponse(WebIdentityGetCredentialResponse&& aOther);
~WebIdentityGetCredentialResponse();
Type
type() const
{
return mType;
}
WebIdentityGetCredentialResponse&
operator=(const nsresult& aRhs);
WebIdentityGetCredentialResponse&
operator=(nsresult&& aRhs);
WebIdentityGetCredentialResponse&
operator=(const IPCIdentityCredential& aRhs);
WebIdentityGetCredentialResponse&
operator=(IPCIdentityCredential&& aRhs);
WebIdentityGetCredentialResponse&
operator=(const WebIdentityGetCredentialResponse& aRhs);
WebIdentityGetCredentialResponse&
operator=(WebIdentityGetCredentialResponse&& aRhs);
nsresult&
get_nsresult()
{
AssertSanity(Tnsresult);
return (*(ptr_nsresult()));
}
const nsresult&
get_nsresult() const
{
AssertSanity(Tnsresult);
return (*(constptr_nsresult()));
}
operator nsresult&()
{
return get_nsresult();
}
operator const nsresult&() const
{
return get_nsresult();
}
IPCIdentityCredential&
get_IPCIdentityCredential()
{
AssertSanity(TIPCIdentityCredential);
return (*(ptr_IPCIdentityCredential()));
}
const IPCIdentityCredential&
get_IPCIdentityCredential() const
{
AssertSanity(TIPCIdentityCredential);
return (*(constptr_IPCIdentityCredential()));
}
operator IPCIdentityCredential&()
{
return get_IPCIdentityCredential();
}
operator const IPCIdentityCredential&() const
{
return get_IPCIdentityCredential();
}
private:
union {
nsresult mVnsresult;
IPCIdentityCredential mVIPCIdentityCredential;
};
Type mType;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::WebIdentityGetCredentialResponse>
{
typedef ::mozilla::dom::WebIdentityGetCredentialResponse 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 PWebIdentityParent;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PWebIdentityChild;
} // namespace dom
} // namespace mozilla
//-----------------------------------------------------------------------------
// Code common to PWebIdentityChild and PWebIdentityParent
//
namespace mozilla {
namespace dom {
namespace PWebIdentity {
nsresult
CreateEndpoints(
mozilla::ipc::EndpointProcInfo aParentDestInfo,
mozilla::ipc::EndpointProcInfo aChildDestInfo,
mozilla::ipc::Endpoint<::mozilla::dom::PWebIdentityParent>* aParent,
mozilla::ipc::Endpoint<::mozilla::dom::PWebIdentityChild>* aChild);
nsresult
CreateEndpoints(
mozilla::ipc::Endpoint<::mozilla::dom::PWebIdentityParent>* aParent,
mozilla::ipc::Endpoint<::mozilla::dom::PWebIdentityChild>* aChild);
enum MessageType {
PWebIdentityStart = PWebIdentityMsgStart << 16,
Msg_RequestCancel__ID,
Msg_GetIdentityCredential__ID,
Reply_GetIdentityCredential__ID,
Msg_DisconnectIdentityCredential__ID,
Reply_DisconnectIdentityCredential__ID,
Msg_PreventSilentAccess__ID,
Reply_PreventSilentAccess__ID,
Msg_SetLoginStatus__ID,
Reply_SetLoginStatus__ID,
Msg___delete____ID,
Reply___delete____ID,
PWebIdentityEnd
};
mozilla::UniquePtr<IPC::Message>
Msg_RequestCancel(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_GetIdentityCredential(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_GetIdentityCredential(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_DisconnectIdentityCredential(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_DisconnectIdentityCredential(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_PreventSilentAccess(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_PreventSilentAccess(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_SetLoginStatus(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_SetLoginStatus(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 PWebIdentity
} // namespace dom
} // namespace mozilla
#endif // ifndef PWebIdentity_h