Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#ifndef PBackgroundLSSharedTypes_h
#define PBackgroundLSSharedTypes_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/dom/LSValue.h"
#include "mozilla/ipc/IPDLStructMember.h"
#include "mozilla/ipc/PBackgroundSharedTypes.h"
#include "mozilla/ipc/ProtocolTypes.h"
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct LSRequestCommonParams|
//
namespace mozilla {
namespace dom {
class LSRequestCommonParams final
{
private:
typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
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
LSRequestCommonParams() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT LSRequestCommonParams(
const PrincipalInfo& _principalInfo,
const PrincipalInfo& _storagePrincipalInfo,
const nsCString& _originKey) :
principalInfo_(_principalInfo),
storagePrincipalInfo_(_storagePrincipalInfo),
originKey_(_originKey)
{
}
MOZ_IMPLICIT LSRequestCommonParams(
PrincipalInfo&& _principalInfo,
PrincipalInfo&& _storagePrincipalInfo,
nsCString&& _originKey) :
principalInfo_(std::move(_principalInfo)),
storagePrincipalInfo_(std::move(_storagePrincipalInfo)),
originKey_(std::move(_originKey))
{
}
PrincipalInfo&
principalInfo()
{
return principalInfo_;
}
const PrincipalInfo&
principalInfo() const
{
return principalInfo_;
}
PrincipalInfo&
storagePrincipalInfo()
{
return storagePrincipalInfo_;
}
const PrincipalInfo&
storagePrincipalInfo() const
{
return storagePrincipalInfo_;
}
nsCString&
originKey()
{
return originKey_;
}
const nsCString&
originKey() const
{
return originKey_;
}
private:
::mozilla::ipc::IPDLStructMember<PrincipalInfo> principalInfo_;
::mozilla::ipc::IPDLStructMember<PrincipalInfo> storagePrincipalInfo_;
::mozilla::ipc::IPDLStructMember<nsCString> originKey_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::LSRequestCommonParams>
{
typedef ::mozilla::dom::LSRequestCommonParams 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 LSRequestPreloadDatastoreParams|
//
namespace mozilla {
namespace dom {
class LSRequestPreloadDatastoreParams final
{
private:
typedef ::mozilla::dom::LSRequestCommonParams LSRequestCommonParams;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
LSRequestPreloadDatastoreParams() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT LSRequestPreloadDatastoreParams(const LSRequestCommonParams& _commonParams) :
commonParams_(_commonParams)
{
}
MOZ_IMPLICIT LSRequestPreloadDatastoreParams(LSRequestCommonParams&& _commonParams) :
commonParams_(std::move(_commonParams))
{
}
LSRequestCommonParams&
commonParams()
{
return commonParams_;
}
const LSRequestCommonParams&
commonParams() const
{
return commonParams_;
}
private:
::mozilla::ipc::IPDLStructMember<LSRequestCommonParams> commonParams_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::LSRequestPreloadDatastoreParams>
{
typedef ::mozilla::dom::LSRequestPreloadDatastoreParams 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 LSRequestPrepareDatastoreParams|
//
namespace mozilla {
namespace dom {
class LSRequestPrepareDatastoreParams final
{
private:
typedef ::mozilla::dom::LSRequestCommonParams LSRequestCommonParams;
typedef ::nsID nsID;
typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
LSRequestPrepareDatastoreParams() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT LSRequestPrepareDatastoreParams(
const LSRequestCommonParams& _commonParams,
const mozilla::Maybe<nsID>& _clientId,
const mozilla::Maybe<PrincipalInfo>& _clientPrincipalInfo) :
commonParams_(_commonParams),
clientId_(_clientId),
clientPrincipalInfo_(_clientPrincipalInfo)
{
}
MOZ_IMPLICIT LSRequestPrepareDatastoreParams(
LSRequestCommonParams&& _commonParams,
mozilla::Maybe<nsID>&& _clientId,
mozilla::Maybe<PrincipalInfo>&& _clientPrincipalInfo) :
commonParams_(std::move(_commonParams)),
clientId_(std::move(_clientId)),
clientPrincipalInfo_(std::move(_clientPrincipalInfo))
{
}
LSRequestCommonParams&
commonParams()
{
return commonParams_;
}
const LSRequestCommonParams&
commonParams() const
{
return commonParams_;
}
mozilla::Maybe<nsID>&
clientId()
{
return clientId_;
}
const mozilla::Maybe<nsID>&
clientId() const
{
return clientId_;
}
mozilla::Maybe<PrincipalInfo>&
clientPrincipalInfo()
{
return clientPrincipalInfo_;
}
const mozilla::Maybe<PrincipalInfo>&
clientPrincipalInfo() const
{
return clientPrincipalInfo_;
}
private:
::mozilla::ipc::IPDLStructMember<LSRequestCommonParams> commonParams_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsID>> clientId_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<PrincipalInfo>> clientPrincipalInfo_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::LSRequestPrepareDatastoreParams>
{
typedef ::mozilla::dom::LSRequestPrepareDatastoreParams 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 LSRequestPrepareObserverParams|
//
namespace mozilla {
namespace dom {
class LSRequestPrepareObserverParams final
{
private:
typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
typedef ::nsID nsID;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
LSRequestPrepareObserverParams() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT LSRequestPrepareObserverParams(
const PrincipalInfo& _principalInfo,
const PrincipalInfo& _storagePrincipalInfo,
const mozilla::Maybe<nsID>& _clientId,
const mozilla::Maybe<PrincipalInfo>& _clientPrincipalInfo) :
principalInfo_(_principalInfo),
storagePrincipalInfo_(_storagePrincipalInfo),
clientId_(_clientId),
clientPrincipalInfo_(_clientPrincipalInfo)
{
}
MOZ_IMPLICIT LSRequestPrepareObserverParams(
PrincipalInfo&& _principalInfo,
PrincipalInfo&& _storagePrincipalInfo,
mozilla::Maybe<nsID>&& _clientId,
mozilla::Maybe<PrincipalInfo>&& _clientPrincipalInfo) :
principalInfo_(std::move(_principalInfo)),
storagePrincipalInfo_(std::move(_storagePrincipalInfo)),
clientId_(std::move(_clientId)),
clientPrincipalInfo_(std::move(_clientPrincipalInfo))
{
}
PrincipalInfo&
principalInfo()
{
return principalInfo_;
}
const PrincipalInfo&
principalInfo() const
{
return principalInfo_;
}
PrincipalInfo&
storagePrincipalInfo()
{
return storagePrincipalInfo_;
}
const PrincipalInfo&
storagePrincipalInfo() const
{
return storagePrincipalInfo_;
}
mozilla::Maybe<nsID>&
clientId()
{
return clientId_;
}
const mozilla::Maybe<nsID>&
clientId() const
{
return clientId_;
}
mozilla::Maybe<PrincipalInfo>&
clientPrincipalInfo()
{
return clientPrincipalInfo_;
}
const mozilla::Maybe<PrincipalInfo>&
clientPrincipalInfo() const
{
return clientPrincipalInfo_;
}
private:
::mozilla::ipc::IPDLStructMember<PrincipalInfo> principalInfo_;
::mozilla::ipc::IPDLStructMember<PrincipalInfo> storagePrincipalInfo_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsID>> clientId_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<PrincipalInfo>> clientPrincipalInfo_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::LSRequestPrepareObserverParams>
{
typedef ::mozilla::dom::LSRequestPrepareObserverParams 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 LSRequestParams|
//
namespace mozilla {
namespace dom {
class LSRequestParams final
{
public:
enum Type {
T__None,
TLSRequestPreloadDatastoreParams = 1,
TLSRequestPrepareDatastoreParams,
TLSRequestPrepareObserverParams,
T__Last = TLSRequestPrepareObserverParams
};
private:
typedef ::mozilla::dom::LSRequestPreloadDatastoreParams LSRequestPreloadDatastoreParams;
typedef ::mozilla::dom::LSRequestPrepareDatastoreParams LSRequestPrepareDatastoreParams;
typedef ::mozilla::dom::LSRequestPrepareObserverParams LSRequestPrepareObserverParams;
typedef LSRequestPreloadDatastoreParams LSRequestPreloadDatastoreParams__tdef;
typedef LSRequestPrepareDatastoreParams LSRequestPrepareDatastoreParams__tdef;
typedef LSRequestPrepareObserverParams LSRequestPrepareObserverParams__tdef;
union Value {
mozilla::AlignedStorage2<LSRequestPreloadDatastoreParams> VLSRequestPreloadDatastoreParams;
mozilla::AlignedStorage2<LSRequestPrepareDatastoreParams> VLSRequestPrepareDatastoreParams;
mozilla::AlignedStorage2<LSRequestPrepareObserverParams> VLSRequestPrepareObserverParams;
};
LSRequestPreloadDatastoreParams*
ptr_LSRequestPreloadDatastoreParams()
{
return ((mValue).VLSRequestPreloadDatastoreParams).addr();
}
const LSRequestPreloadDatastoreParams*
constptr_LSRequestPreloadDatastoreParams() const
{
return ((mValue).VLSRequestPreloadDatastoreParams).addr();
}
LSRequestPrepareDatastoreParams*
ptr_LSRequestPrepareDatastoreParams()
{
return ((mValue).VLSRequestPrepareDatastoreParams).addr();
}
const LSRequestPrepareDatastoreParams*
constptr_LSRequestPrepareDatastoreParams() const
{
return ((mValue).VLSRequestPrepareDatastoreParams).addr();
}
LSRequestPrepareObserverParams*
ptr_LSRequestPrepareObserverParams()
{
return ((mValue).VLSRequestPrepareObserverParams).addr();
}
const LSRequestPrepareObserverParams*
constptr_LSRequestPrepareObserverParams() const
{
return ((mValue).VLSRequestPrepareObserverParams).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 LSRequestParams() :
mType(T__None)
{
}
MOZ_IMPLICIT LSRequestParams(const LSRequestPreloadDatastoreParams& aOther);
MOZ_IMPLICIT LSRequestParams(LSRequestPreloadDatastoreParams&& aOther);
MOZ_IMPLICIT LSRequestParams(const LSRequestPrepareDatastoreParams& aOther);
MOZ_IMPLICIT LSRequestParams(LSRequestPrepareDatastoreParams&& aOther);
MOZ_IMPLICIT LSRequestParams(const LSRequestPrepareObserverParams& aOther);
MOZ_IMPLICIT LSRequestParams(LSRequestPrepareObserverParams&& aOther);
MOZ_IMPLICIT LSRequestParams(const LSRequestParams& aOther);
MOZ_IMPLICIT LSRequestParams(LSRequestParams&& aOther);
~LSRequestParams();
Type
type() const
{
return mType;
}
LSRequestParams&
operator=(const LSRequestPreloadDatastoreParams& aRhs);
LSRequestParams&
operator=(LSRequestPreloadDatastoreParams&& aRhs);
LSRequestParams&
operator=(const LSRequestPrepareDatastoreParams& aRhs);
LSRequestParams&
operator=(LSRequestPrepareDatastoreParams&& aRhs);
LSRequestParams&
operator=(const LSRequestPrepareObserverParams& aRhs);
LSRequestParams&
operator=(LSRequestPrepareObserverParams&& aRhs);
LSRequestParams&
operator=(const LSRequestParams& aRhs);
LSRequestParams&
operator=(LSRequestParams&& aRhs);
LSRequestPreloadDatastoreParams&
get_LSRequestPreloadDatastoreParams()
{
AssertSanity(TLSRequestPreloadDatastoreParams);
return (*(ptr_LSRequestPreloadDatastoreParams()));
}
const LSRequestPreloadDatastoreParams&
get_LSRequestPreloadDatastoreParams() const
{
AssertSanity(TLSRequestPreloadDatastoreParams);
return (*(constptr_LSRequestPreloadDatastoreParams()));
}
operator LSRequestPreloadDatastoreParams&()
{
return get_LSRequestPreloadDatastoreParams();
}
operator const LSRequestPreloadDatastoreParams&() const
{
return get_LSRequestPreloadDatastoreParams();
}
LSRequestPrepareDatastoreParams&
get_LSRequestPrepareDatastoreParams()
{
AssertSanity(TLSRequestPrepareDatastoreParams);
return (*(ptr_LSRequestPrepareDatastoreParams()));
}
const LSRequestPrepareDatastoreParams&
get_LSRequestPrepareDatastoreParams() const
{
AssertSanity(TLSRequestPrepareDatastoreParams);
return (*(constptr_LSRequestPrepareDatastoreParams()));
}
operator LSRequestPrepareDatastoreParams&()
{
return get_LSRequestPrepareDatastoreParams();
}
operator const LSRequestPrepareDatastoreParams&() const
{
return get_LSRequestPrepareDatastoreParams();
}
LSRequestPrepareObserverParams&
get_LSRequestPrepareObserverParams()
{
AssertSanity(TLSRequestPrepareObserverParams);
return (*(ptr_LSRequestPrepareObserverParams()));
}
const LSRequestPrepareObserverParams&
get_LSRequestPrepareObserverParams() const
{
AssertSanity(TLSRequestPrepareObserverParams);
return (*(constptr_LSRequestPrepareObserverParams()));
}
operator LSRequestPrepareObserverParams&()
{
return get_LSRequestPrepareObserverParams();
}
operator const LSRequestPrepareObserverParams&() const
{
return get_LSRequestPrepareObserverParams();
}
private:
Value mValue;
Type mType;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::LSRequestParams>
{
typedef ::mozilla::dom::LSRequestParams 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 LSSimpleRequestPreloadedParams|
//
namespace mozilla {
namespace dom {
class LSSimpleRequestPreloadedParams final
{
private:
typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
LSSimpleRequestPreloadedParams() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT LSSimpleRequestPreloadedParams(
const PrincipalInfo& _principalInfo,
const PrincipalInfo& _storagePrincipalInfo) :
principalInfo_(_principalInfo),
storagePrincipalInfo_(_storagePrincipalInfo)
{
}
MOZ_IMPLICIT LSSimpleRequestPreloadedParams(
PrincipalInfo&& _principalInfo,
PrincipalInfo&& _storagePrincipalInfo) :
principalInfo_(std::move(_principalInfo)),
storagePrincipalInfo_(std::move(_storagePrincipalInfo))
{
}
PrincipalInfo&
principalInfo()
{
return principalInfo_;
}
const PrincipalInfo&
principalInfo() const
{
return principalInfo_;
}
PrincipalInfo&
storagePrincipalInfo()
{
return storagePrincipalInfo_;
}
const PrincipalInfo&
storagePrincipalInfo() const
{
return storagePrincipalInfo_;
}
private:
::mozilla::ipc::IPDLStructMember<PrincipalInfo> principalInfo_;
::mozilla::ipc::IPDLStructMember<PrincipalInfo> storagePrincipalInfo_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::LSSimpleRequestPreloadedParams>
{
typedef ::mozilla::dom::LSSimpleRequestPreloadedParams 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 LSSimpleRequestGetStateParams|
//
namespace mozilla {
namespace dom {
class LSSimpleRequestGetStateParams final
{
private:
typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
LSSimpleRequestGetStateParams() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT LSSimpleRequestGetStateParams(
const PrincipalInfo& _principalInfo,
const PrincipalInfo& _storagePrincipalInfo) :
principalInfo_(_principalInfo),
storagePrincipalInfo_(_storagePrincipalInfo)
{
}
MOZ_IMPLICIT LSSimpleRequestGetStateParams(
PrincipalInfo&& _principalInfo,
PrincipalInfo&& _storagePrincipalInfo) :
principalInfo_(std::move(_principalInfo)),
storagePrincipalInfo_(std::move(_storagePrincipalInfo))
{
}
PrincipalInfo&
principalInfo()
{
return principalInfo_;
}
const PrincipalInfo&
principalInfo() const
{
return principalInfo_;
}
PrincipalInfo&
storagePrincipalInfo()
{
return storagePrincipalInfo_;
}
const PrincipalInfo&
storagePrincipalInfo() const
{
return storagePrincipalInfo_;
}
private:
::mozilla::ipc::IPDLStructMember<PrincipalInfo> principalInfo_;
::mozilla::ipc::IPDLStructMember<PrincipalInfo> storagePrincipalInfo_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::LSSimpleRequestGetStateParams>
{
typedef ::mozilla::dom::LSSimpleRequestGetStateParams 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 LSSimpleRequestParams|
//
namespace mozilla {
namespace dom {
class LSSimpleRequestParams final
{
public:
enum Type {
T__None,
TLSSimpleRequestPreloadedParams = 1,
TLSSimpleRequestGetStateParams,
T__Last = TLSSimpleRequestGetStateParams
};
private:
typedef ::mozilla::dom::LSSimpleRequestPreloadedParams LSSimpleRequestPreloadedParams;
typedef ::mozilla::dom::LSSimpleRequestGetStateParams LSSimpleRequestGetStateParams;
typedef LSSimpleRequestPreloadedParams LSSimpleRequestPreloadedParams__tdef;
typedef LSSimpleRequestGetStateParams LSSimpleRequestGetStateParams__tdef;
union Value {
mozilla::AlignedStorage2<LSSimpleRequestPreloadedParams> VLSSimpleRequestPreloadedParams;
mozilla::AlignedStorage2<LSSimpleRequestGetStateParams> VLSSimpleRequestGetStateParams;
};
LSSimpleRequestPreloadedParams*
ptr_LSSimpleRequestPreloadedParams()
{
return ((mValue).VLSSimpleRequestPreloadedParams).addr();
}
const LSSimpleRequestPreloadedParams*
constptr_LSSimpleRequestPreloadedParams() const
{
return ((mValue).VLSSimpleRequestPreloadedParams).addr();
}
LSSimpleRequestGetStateParams*
ptr_LSSimpleRequestGetStateParams()
{
return ((mValue).VLSSimpleRequestGetStateParams).addr();
}
const LSSimpleRequestGetStateParams*
constptr_LSSimpleRequestGetStateParams() const
{
return ((mValue).VLSSimpleRequestGetStateParams).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 LSSimpleRequestParams() :
mType(T__None)
{
}
MOZ_IMPLICIT LSSimpleRequestParams(const LSSimpleRequestPreloadedParams& aOther);
MOZ_IMPLICIT LSSimpleRequestParams(LSSimpleRequestPreloadedParams&& aOther);
MOZ_IMPLICIT LSSimpleRequestParams(const LSSimpleRequestGetStateParams& aOther);
MOZ_IMPLICIT LSSimpleRequestParams(LSSimpleRequestGetStateParams&& aOther);
MOZ_IMPLICIT LSSimpleRequestParams(const LSSimpleRequestParams& aOther);
MOZ_IMPLICIT LSSimpleRequestParams(LSSimpleRequestParams&& aOther);
~LSSimpleRequestParams();
Type
type() const
{
return mType;
}
LSSimpleRequestParams&
operator=(const LSSimpleRequestPreloadedParams& aRhs);
LSSimpleRequestParams&
operator=(LSSimpleRequestPreloadedParams&& aRhs);
LSSimpleRequestParams&
operator=(const LSSimpleRequestGetStateParams& aRhs);
LSSimpleRequestParams&
operator=(LSSimpleRequestGetStateParams&& aRhs);
LSSimpleRequestParams&
operator=(const LSSimpleRequestParams& aRhs);
LSSimpleRequestParams&
operator=(LSSimpleRequestParams&& aRhs);
LSSimpleRequestPreloadedParams&
get_LSSimpleRequestPreloadedParams()
{
AssertSanity(TLSSimpleRequestPreloadedParams);
return (*(ptr_LSSimpleRequestPreloadedParams()));
}
const LSSimpleRequestPreloadedParams&
get_LSSimpleRequestPreloadedParams() const
{
AssertSanity(TLSSimpleRequestPreloadedParams);
return (*(constptr_LSSimpleRequestPreloadedParams()));
}
operator LSSimpleRequestPreloadedParams&()
{
return get_LSSimpleRequestPreloadedParams();
}
operator const LSSimpleRequestPreloadedParams&() const
{
return get_LSSimpleRequestPreloadedParams();
}
LSSimpleRequestGetStateParams&
get_LSSimpleRequestGetStateParams()
{
AssertSanity(TLSSimpleRequestGetStateParams);
return (*(ptr_LSSimpleRequestGetStateParams()));
}
const LSSimpleRequestGetStateParams&
get_LSSimpleRequestGetStateParams() const
{
AssertSanity(TLSSimpleRequestGetStateParams);
return (*(constptr_LSSimpleRequestGetStateParams()));
}
operator LSSimpleRequestGetStateParams&()
{
return get_LSSimpleRequestGetStateParams();
}
operator const LSSimpleRequestGetStateParams&() const
{
return get_LSSimpleRequestGetStateParams();
}
private:
Value mValue;
Type mType;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::LSSimpleRequestParams>
{
typedef ::mozilla::dom::LSSimpleRequestParams 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 LSItemInfo|
//
namespace mozilla {
namespace dom {
class LSItemInfo final
{
private:
typedef ::nsString nsString;
typedef ::mozilla::dom::LSValue LSValue;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
LSItemInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT LSItemInfo(
const nsString& _key,
const LSValue& _value) :
key_(_key),
value_(_value)
{
}
MOZ_IMPLICIT LSItemInfo(
nsString&& _key,
LSValue&& _value) :
key_(std::move(_key)),
value_(std::move(_value))
{
}
nsString&
key()
{
return key_;
}
const nsString&
key() const
{
return key_;
}
LSValue&
value()
{
return value_;
}
const LSValue&
value() const
{
return value_;
}
private:
::mozilla::ipc::IPDLStructMember<nsString> key_;
::mozilla::ipc::IPDLStructMember<LSValue> value_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::LSItemInfo>
{
typedef ::mozilla::dom::LSItemInfo paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
#endif // ifndef PBackgroundLSSharedTypes_h