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;
typedef ::nsCString nsCString;
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<nsCString>& _token,
const bool& _isAutoSelected,
const nsCString& _configURL) :
id_(_id),
token_(_token),
isAutoSelected_(_isAutoSelected),
configURL_(_configURL)
{
}
MOZ_IMPLICIT IPCIdentityCredential(
nsString&& _id,
mozilla::Maybe<nsCString>&& _token,
bool&& _isAutoSelected,
nsCString&& _configURL) :
id_(std::move(_id)),
token_(std::move(_token)),
isAutoSelected_(std::move(_isAutoSelected)),
configURL_(std::move(_configURL))
{
}
nsString&
id()
{
return id_;
}
const nsString&
id() const
{
return id_;
}
mozilla::Maybe<nsCString>&
token()
{
return token_;
}
const mozilla::Maybe<nsCString>&
token() const
{
return token_;
}
bool&
isAutoSelected()
{
return isAutoSelected_;
}
const bool&
isAutoSelected() const
{
return isAutoSelected_;
}
nsCString&
configURL()
{
return configURL_;
}
const nsCString&
configURL() const
{
return configURL_;
}
private:
::mozilla::ipc::IPDLStructMember<nsString> id_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsCString>> token_;
::mozilla::ipc::IPDLStructMember<bool> isAutoSelected_;
::mozilla::ipc::IPDLStructMember<nsCString> configURL_;
};
} // 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
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union OpenContinuationWindowResponse|
//
namespace mozilla {
namespace dom {
class OpenContinuationWindowResponse final
{
public:
enum Type {
T__None,
Tnsresult = 1,
Tuint64_t,
T__Last = Tuint64_t
};
private:
typedef ::nsresult nsresult;
typedef ::uint64_t uint64_t;
typedef nsresult nsresult__tdef;
typedef uint64_t uint64_t__tdef;
nsresult*
ptr_nsresult()
{
return (&(mVnsresult));
}
const nsresult*
constptr_nsresult() const
{
return (&(mVnsresult));
}
uint64_t*
ptr_uint64_t()
{
return (&(mVuint64_t));
}
const uint64_t*
constptr_uint64_t() const
{
return (&(mVuint64_t));
}
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 OpenContinuationWindowResponse() :
mType(T__None)
{
}
MOZ_IMPLICIT OpenContinuationWindowResponse(const nsresult& aOther);
MOZ_IMPLICIT OpenContinuationWindowResponse(nsresult&& aOther);
MOZ_IMPLICIT OpenContinuationWindowResponse(const uint64_t& aOther);
MOZ_IMPLICIT OpenContinuationWindowResponse(uint64_t&& aOther);
MOZ_IMPLICIT OpenContinuationWindowResponse(const OpenContinuationWindowResponse& aOther);
MOZ_IMPLICIT OpenContinuationWindowResponse(OpenContinuationWindowResponse&& aOther);
~OpenContinuationWindowResponse();
Type
type() const
{
return mType;
}
OpenContinuationWindowResponse&
operator=(const nsresult& aRhs);
OpenContinuationWindowResponse&
operator=(nsresult&& aRhs);
OpenContinuationWindowResponse&
operator=(const uint64_t& aRhs);
OpenContinuationWindowResponse&
operator=(uint64_t&& aRhs);
OpenContinuationWindowResponse&
operator=(const OpenContinuationWindowResponse& aRhs);
OpenContinuationWindowResponse&
operator=(OpenContinuationWindowResponse&& 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();
}
uint64_t&
get_uint64_t()
{
AssertSanity(Tuint64_t);
return (*(ptr_uint64_t()));
}
const uint64_t&
get_uint64_t() const
{
AssertSanity(Tuint64_t);
return (*(constptr_uint64_t()));
}
operator uint64_t&()
{
return get_uint64_t();
}
operator const uint64_t&() const
{
return get_uint64_t();
}
private:
union {
nsresult mVnsresult;
uint64_t mVuint64_t;
};
Type mType;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::OpenContinuationWindowResponse>
{
typedef ::mozilla::dom::OpenContinuationWindowResponse 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_ResolveContinuationWindow__ID,
Reply_ResolveContinuationWindow__ID,
Msg_IsActiveContinuationWindow__ID,
Reply_IsActiveContinuationWindow__ID,
Msg_OpenContinuationWindow__ID,
Reply_OpenContinuationWindow__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_ResolveContinuationWindow(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_ResolveContinuationWindow(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_IsActiveContinuationWindow(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_IsActiveContinuationWindow(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_OpenContinuationWindow(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_OpenContinuationWindow(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