//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#ifndef RemoteWorkerTypes_h
#define RemoteWorkerTypes_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/OriginTrialsIPCUtils.h"
#include "mozilla/StorageAccess.h"
#include "mozilla/dom/WorkerBinding.h"
#include "mozilla/ipc/IPCCore.h"
#include "mozilla/ipc/IPDLStructMember.h"
#include "nsIPrincipal.h"
#include "nsRFPService.h"
#include "mozilla/dom/ClientIPCTypes.h"
#include "mozilla/dom/IPCServiceWorkerDescriptor.h"
#include "mozilla/dom/IPCServiceWorkerRegistrationDescriptor.h"
#include "mozilla/ipc/PBackgroundSharedTypes.h"
#include "mozilla/ipc/URIParams.h"
#include "mozilla/dom/DOMTypes.h"
#include "mozilla/net/NeckoChannelParams.h"
#include "mozilla/ipc/ProtocolTypes.h"
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ServiceWorkerData|
//
namespace mozilla {
namespace dom {
class ServiceWorkerData final
{
private:
typedef ::mozilla::dom::IPCServiceWorkerDescriptor IPCServiceWorkerDescriptor;
typedef ::mozilla::dom::IPCServiceWorkerRegistrationDescriptor IPCServiceWorkerRegistrationDescriptor;
typedef ::nsString nsString;
typedef ::uint32_t uint32_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ServiceWorkerData() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ServiceWorkerData(
const IPCServiceWorkerDescriptor& _descriptor,
const IPCServiceWorkerRegistrationDescriptor& _registrationDescriptor,
const nsString& _cacheName,
const uint32_t& _loadFlags,
const nsString& _id) :
descriptor_(_descriptor),
registrationDescriptor_(_registrationDescriptor),
cacheName_(_cacheName),
id_(_id),
loadFlags_(_loadFlags)
{
}
MOZ_IMPLICIT ServiceWorkerData(
IPCServiceWorkerDescriptor&& _descriptor,
IPCServiceWorkerRegistrationDescriptor&& _registrationDescriptor,
nsString&& _cacheName,
uint32_t&& _loadFlags,
nsString&& _id) :
descriptor_(std::move(_descriptor)),
registrationDescriptor_(std::move(_registrationDescriptor)),
cacheName_(std::move(_cacheName)),
id_(std::move(_id)),
loadFlags_(std::move(_loadFlags))
{
}
IPCServiceWorkerDescriptor&
descriptor()
{
return descriptor_;
}
const IPCServiceWorkerDescriptor&
descriptor() const
{
return descriptor_;
}
IPCServiceWorkerRegistrationDescriptor&
registrationDescriptor()
{
return registrationDescriptor_;
}
const IPCServiceWorkerRegistrationDescriptor&
registrationDescriptor() const
{
return registrationDescriptor_;
}
nsString&
cacheName()
{
return cacheName_;
}
const nsString&
cacheName() const
{
return cacheName_;
}
uint32_t&
loadFlags()
{
return loadFlags_;
}
const uint32_t&
loadFlags() const
{
return loadFlags_;
}
nsString&
id()
{
return id_;
}
const nsString&
id() const
{
return id_;
}
private:
::mozilla::ipc::IPDLStructMember<IPCServiceWorkerDescriptor> descriptor_;
::mozilla::ipc::IPDLStructMember<IPCServiceWorkerRegistrationDescriptor> registrationDescriptor_;
::mozilla::ipc::IPDLStructMember<nsString> cacheName_;
::mozilla::ipc::IPDLStructMember<nsString> id_;
::mozilla::ipc::IPDLStructMember<uint32_t> loadFlags_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::ServiceWorkerData>
{
typedef ::mozilla::dom::ServiceWorkerData 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 OptionalServiceWorkerData|
//
namespace mozilla {
namespace dom {
class OptionalServiceWorkerData final
{
public:
enum Type {
T__None,
Tvoid_t = 1,
TServiceWorkerData,
T__Last = TServiceWorkerData
};
private:
typedef ::mozilla::void_t void_t;
typedef ::mozilla::dom::ServiceWorkerData ServiceWorkerData;
typedef void_t void_t__tdef;
typedef ServiceWorkerData ServiceWorkerData__tdef;
void_t*
ptr_void_t()
{
return (&(mVvoid_t));
}
const void_t*
constptr_void_t() const
{
return (&(mVvoid_t));
}
ServiceWorkerData*
ptr_ServiceWorkerData()
{
return (&(mVServiceWorkerData));
}
const ServiceWorkerData*
constptr_ServiceWorkerData() const
{
return (&(mVServiceWorkerData));
}
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 OptionalServiceWorkerData() :
mType(T__None)
{
}
MOZ_IMPLICIT OptionalServiceWorkerData(const void_t& aOther);
MOZ_IMPLICIT OptionalServiceWorkerData(void_t&& aOther);
MOZ_IMPLICIT OptionalServiceWorkerData(const ServiceWorkerData& aOther);
MOZ_IMPLICIT OptionalServiceWorkerData(ServiceWorkerData&& aOther);
MOZ_IMPLICIT OptionalServiceWorkerData(const OptionalServiceWorkerData& aOther);
MOZ_IMPLICIT OptionalServiceWorkerData(OptionalServiceWorkerData&& aOther);
~OptionalServiceWorkerData();
Type
type() const
{
return mType;
}
OptionalServiceWorkerData&
operator=(const void_t& aRhs);
OptionalServiceWorkerData&
operator=(void_t&& aRhs);
OptionalServiceWorkerData&
operator=(const ServiceWorkerData& aRhs);
OptionalServiceWorkerData&
operator=(ServiceWorkerData&& aRhs);
OptionalServiceWorkerData&
operator=(const OptionalServiceWorkerData& aRhs);
OptionalServiceWorkerData&
operator=(OptionalServiceWorkerData&& aRhs);
void_t&
get_void_t()
{
AssertSanity(Tvoid_t);
return (*(ptr_void_t()));
}
const void_t&
get_void_t() const
{
AssertSanity(Tvoid_t);
return (*(constptr_void_t()));
}
operator void_t&()
{
return get_void_t();
}
operator const void_t&() const
{
return get_void_t();
}
ServiceWorkerData&
get_ServiceWorkerData()
{
AssertSanity(TServiceWorkerData);
return (*(ptr_ServiceWorkerData()));
}
const ServiceWorkerData&
get_ServiceWorkerData() const
{
AssertSanity(TServiceWorkerData);
return (*(constptr_ServiceWorkerData()));
}
operator ServiceWorkerData&()
{
return get_ServiceWorkerData();
}
operator const ServiceWorkerData&() const
{
return get_ServiceWorkerData();
}
private:
union {
void_t mVvoid_t;
ServiceWorkerData mVServiceWorkerData;
};
Type mType;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::OptionalServiceWorkerData>
{
typedef ::mozilla::dom::OptionalServiceWorkerData 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 RemoteWorkerData|
//
namespace mozilla {
namespace dom {
class RemoteWorkerData final
{
private:
typedef ::nsString nsString;
typedef ::mozilla::ipc::URIParams URIParams;
typedef ::mozilla::dom::WorkerOptions WorkerOptions;
typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
typedef ::mozilla::net::CookieJarSettingsArgs CookieJarSettingsArgs;
typedef ::nsCString nsCString;
typedef ::mozilla::dom::IPCClientInfo IPCClientInfo;
typedef ::nsIReferrerInfo nsIReferrerInfo;
typedef ::mozilla::StorageAccess StorageAccess;
typedef ::mozilla::RFPTargetSet RFPTargetSet;
typedef ::mozilla::OriginTrials OriginTrials;
typedef ::mozilla::dom::OptionalServiceWorkerData OptionalServiceWorkerData;
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
RemoteWorkerData() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT RemoteWorkerData(
const nsString& _originalScriptURL,
const URIParams& _baseScriptURL,
const URIParams& _resolvedScriptURL,
const WorkerOptions& _workerOptions,
const PrincipalInfo& _loadingPrincipalInfo,
const PrincipalInfo& _principalInfo,
const PrincipalInfo& _partitionedPrincipalInfo,
const bool& _useRegularPrincipal,
const bool& _usingStorageAccess,
const CookieJarSettingsArgs& _cookieJarSettings,
const nsCString& _domain,
const bool& _isSecureContext,
const mozilla::Maybe<IPCClientInfo>& _clientInfo,
nsIReferrerInfo* _referrerInfo,
const StorageAccess& _storageAccess,
const bool& _isThirdPartyContext,
const bool& _shouldResistFingerprinting,
const mozilla::Maybe<RFPTargetSet>& _overriddenFingerprintingSettings,
const bool& _isOn3PCBExceptionList,
const OriginTrials& _originTrials,
const OptionalServiceWorkerData& _serviceWorkerData,
const nsID& _agentClusterId,
const nsCString& _remoteType) :
originalScriptURL_(_originalScriptURL),
baseScriptURL_(_baseScriptURL),
resolvedScriptURL_(_resolvedScriptURL),
workerOptions_(_workerOptions),
loadingPrincipalInfo_(_loadingPrincipalInfo),
principalInfo_(_principalInfo),
partitionedPrincipalInfo_(_partitionedPrincipalInfo),
useRegularPrincipal_(_useRegularPrincipal),
usingStorageAccess_(_usingStorageAccess),
cookieJarSettings_(_cookieJarSettings),
domain_(_domain),
isSecureContext_(_isSecureContext),
clientInfo_(_clientInfo),
referrerInfo_(_referrerInfo),
storageAccess_(_storageAccess),
isThirdPartyContext_(_isThirdPartyContext),
shouldResistFingerprinting_(_shouldResistFingerprinting),
overriddenFingerprintingSettings_(_overriddenFingerprintingSettings),
isOn3PCBExceptionList_(_isOn3PCBExceptionList),
originTrials_(_originTrials),
serviceWorkerData_(_serviceWorkerData),
agentClusterId_(_agentClusterId),
remoteType_(_remoteType)
{
}
MOZ_IMPLICIT RemoteWorkerData(
nsString&& _originalScriptURL,
URIParams&& _baseScriptURL,
URIParams&& _resolvedScriptURL,
WorkerOptions&& _workerOptions,
PrincipalInfo&& _loadingPrincipalInfo,
PrincipalInfo&& _principalInfo,
PrincipalInfo&& _partitionedPrincipalInfo,
bool&& _useRegularPrincipal,
bool&& _usingStorageAccess,
CookieJarSettingsArgs&& _cookieJarSettings,
nsCString&& _domain,
bool&& _isSecureContext,
mozilla::Maybe<IPCClientInfo>&& _clientInfo,
RefPtr<nsIReferrerInfo>&& _referrerInfo,
StorageAccess&& _storageAccess,
bool&& _isThirdPartyContext,
bool&& _shouldResistFingerprinting,
mozilla::Maybe<RFPTargetSet>&& _overriddenFingerprintingSettings,
bool&& _isOn3PCBExceptionList,
OriginTrials&& _originTrials,
OptionalServiceWorkerData&& _serviceWorkerData,
nsID&& _agentClusterId,
nsCString&& _remoteType) :
originalScriptURL_(std::move(_originalScriptURL)),
baseScriptURL_(std::move(_baseScriptURL)),
resolvedScriptURL_(std::move(_resolvedScriptURL)),
workerOptions_(std::move(_workerOptions)),
loadingPrincipalInfo_(std::move(_loadingPrincipalInfo)),
principalInfo_(std::move(_principalInfo)),
partitionedPrincipalInfo_(std::move(_partitionedPrincipalInfo)),
useRegularPrincipal_(std::move(_useRegularPrincipal)),
usingStorageAccess_(std::move(_usingStorageAccess)),
cookieJarSettings_(std::move(_cookieJarSettings)),
domain_(std::move(_domain)),
isSecureContext_(std::move(_isSecureContext)),
clientInfo_(std::move(_clientInfo)),
referrerInfo_(std::move(_referrerInfo)),
storageAccess_(std::move(_storageAccess)),
isThirdPartyContext_(std::move(_isThirdPartyContext)),
shouldResistFingerprinting_(std::move(_shouldResistFingerprinting)),
overriddenFingerprintingSettings_(std::move(_overriddenFingerprintingSettings)),
isOn3PCBExceptionList_(std::move(_isOn3PCBExceptionList)),
originTrials_(std::move(_originTrials)),
serviceWorkerData_(std::move(_serviceWorkerData)),
agentClusterId_(std::move(_agentClusterId)),
remoteType_(std::move(_remoteType))
{
}
nsString&
originalScriptURL()
{
return originalScriptURL_;
}
const nsString&
originalScriptURL() const
{
return originalScriptURL_;
}
URIParams&
baseScriptURL()
{
return baseScriptURL_;
}
const URIParams&
baseScriptURL() const
{
return baseScriptURL_;
}
URIParams&
resolvedScriptURL()
{
return resolvedScriptURL_;
}
const URIParams&
resolvedScriptURL() const
{
return resolvedScriptURL_;
}
WorkerOptions&
workerOptions()
{
return workerOptions_;
}
const WorkerOptions&
workerOptions() const
{
return workerOptions_;
}
PrincipalInfo&
loadingPrincipalInfo()
{
return loadingPrincipalInfo_;
}
const PrincipalInfo&
loadingPrincipalInfo() const
{
return loadingPrincipalInfo_;
}
PrincipalInfo&
principalInfo()
{
return principalInfo_;
}
const PrincipalInfo&
principalInfo() const
{
return principalInfo_;
}
PrincipalInfo&
partitionedPrincipalInfo()
{
return partitionedPrincipalInfo_;
}
const PrincipalInfo&
partitionedPrincipalInfo() const
{
return partitionedPrincipalInfo_;
}
bool&
useRegularPrincipal()
{
return useRegularPrincipal_;
}
const bool&
useRegularPrincipal() const
{
return useRegularPrincipal_;
}
bool&
usingStorageAccess()
{
return usingStorageAccess_;
}
const bool&
usingStorageAccess() const
{
return usingStorageAccess_;
}
CookieJarSettingsArgs&
cookieJarSettings()
{
return cookieJarSettings_;
}
const CookieJarSettingsArgs&
cookieJarSettings() const
{
return cookieJarSettings_;
}
nsCString&
domain()
{
return domain_;
}
const nsCString&
domain() const
{
return domain_;
}
bool&
isSecureContext()
{
return isSecureContext_;
}
const bool&
isSecureContext() const
{
return isSecureContext_;
}
mozilla::Maybe<IPCClientInfo>&
clientInfo()
{
return clientInfo_;
}
const mozilla::Maybe<IPCClientInfo>&
clientInfo() const
{
return clientInfo_;
}
RefPtr<nsIReferrerInfo>&
referrerInfo()
{
return referrerInfo_;
}
nsIReferrerInfo*
referrerInfo() const
{
return referrerInfo_;
}
StorageAccess&
storageAccess()
{
return storageAccess_;
}
const StorageAccess&
storageAccess() const
{
return storageAccess_;
}
bool&
isThirdPartyContext()
{
return isThirdPartyContext_;
}
const bool&
isThirdPartyContext() const
{
return isThirdPartyContext_;
}
bool&
shouldResistFingerprinting()
{
return shouldResistFingerprinting_;
}
const bool&
shouldResistFingerprinting() const
{
return shouldResistFingerprinting_;
}
mozilla::Maybe<RFPTargetSet>&
overriddenFingerprintingSettings()
{
return overriddenFingerprintingSettings_;
}
const mozilla::Maybe<RFPTargetSet>&
overriddenFingerprintingSettings() const
{
return overriddenFingerprintingSettings_;
}
bool&
isOn3PCBExceptionList()
{
return isOn3PCBExceptionList_;
}
const bool&
isOn3PCBExceptionList() const
{
return isOn3PCBExceptionList_;
}
OriginTrials&
originTrials()
{
return originTrials_;
}
const OriginTrials&
originTrials() const
{
return originTrials_;
}
OptionalServiceWorkerData&
serviceWorkerData()
{
return serviceWorkerData_;
}
const OptionalServiceWorkerData&
serviceWorkerData() const
{
return serviceWorkerData_;
}
nsID&
agentClusterId()
{
return agentClusterId_;
}
const nsID&
agentClusterId() const
{
return agentClusterId_;
}
nsCString&
remoteType()
{
return remoteType_;
}
const nsCString&
remoteType() const
{
return remoteType_;
}
private:
::mozilla::ipc::IPDLStructMember<nsString> originalScriptURL_;
::mozilla::ipc::IPDLStructMember<URIParams> baseScriptURL_;
::mozilla::ipc::IPDLStructMember<URIParams> resolvedScriptURL_;
::mozilla::ipc::IPDLStructMember<WorkerOptions> workerOptions_;
::mozilla::ipc::IPDLStructMember<PrincipalInfo> loadingPrincipalInfo_;
::mozilla::ipc::IPDLStructMember<PrincipalInfo> principalInfo_;
::mozilla::ipc::IPDLStructMember<PrincipalInfo> partitionedPrincipalInfo_;
::mozilla::ipc::IPDLStructMember<bool> useRegularPrincipal_;
::mozilla::ipc::IPDLStructMember<bool> usingStorageAccess_;
::mozilla::ipc::IPDLStructMember<CookieJarSettingsArgs> cookieJarSettings_;
::mozilla::ipc::IPDLStructMember<nsCString> domain_;
::mozilla::ipc::IPDLStructMember<bool> isSecureContext_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCClientInfo>> clientInfo_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIReferrerInfo>> referrerInfo_;
::mozilla::ipc::IPDLStructMember<StorageAccess> storageAccess_;
::mozilla::ipc::IPDLStructMember<bool> isThirdPartyContext_;
::mozilla::ipc::IPDLStructMember<bool> shouldResistFingerprinting_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<RFPTargetSet>> overriddenFingerprintingSettings_;
::mozilla::ipc::IPDLStructMember<bool> isOn3PCBExceptionList_;
::mozilla::ipc::IPDLStructMember<OriginTrials> originTrials_;
::mozilla::ipc::IPDLStructMember<OptionalServiceWorkerData> serviceWorkerData_;
::mozilla::ipc::IPDLStructMember<nsID> agentClusterId_;
::mozilla::ipc::IPDLStructMember<nsCString> remoteType_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::RemoteWorkerData>
{
typedef ::mozilla::dom::RemoteWorkerData 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 ErrorDataNote|
//
namespace mozilla {
namespace dom {
class ErrorDataNote final
{
private:
typedef ::uint32_t uint32_t;
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
ErrorDataNote() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ErrorDataNote(
const uint32_t& _lineNumber,
const uint32_t& _columnNumber,
const nsString& _message,
const nsCString& _filename) :
message_(_message),
filename_(_filename),
lineNumber_(_lineNumber),
columnNumber_(_columnNumber)
{
}
MOZ_IMPLICIT ErrorDataNote(
uint32_t&& _lineNumber,
uint32_t&& _columnNumber,
nsString&& _message,
nsCString&& _filename) :
message_(std::move(_message)),
filename_(std::move(_filename)),
lineNumber_(std::move(_lineNumber)),
columnNumber_(std::move(_columnNumber))
{
}
uint32_t&
lineNumber()
{
return lineNumber_;
}
const uint32_t&
lineNumber() const
{
return lineNumber_;
}
uint32_t&
columnNumber()
{
return columnNumber_;
}
const uint32_t&
columnNumber() const
{
return columnNumber_;
}
nsString&
message()
{
return message_;
}
const nsString&
message() const
{
return message_;
}
nsCString&
filename()
{
return filename_;
}
const nsCString&
filename() const
{
return filename_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<nsString> message_;
::mozilla::ipc::IPDLStructMember<nsCString> filename_;
::mozilla::ipc::IPDLStructMember<uint32_t> lineNumber_;
::mozilla::ipc::IPDLStructMember<uint32_t> columnNumber_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::ErrorDataNote>
{
typedef ::mozilla::dom::ErrorDataNote 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 ErrorData|
//
namespace mozilla {
namespace dom {
class ErrorData final
{
private:
typedef ::uint32_t uint32_t;
typedef ::nsString nsString;
typedef ::nsCString nsCString;
typedef ::mozilla::dom::ErrorDataNote ErrorDataNote;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ErrorData() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ErrorData(
const bool& _isWarning,
const uint32_t& _lineNumber,
const uint32_t& _columnNumber,
const nsString& _message,
const nsCString& _filename,
const nsTArray<ErrorDataNote>& _notes) :
isWarning_(_isWarning),
message_(_message),
filename_(_filename),
notes_(_notes),
lineNumber_(_lineNumber),
columnNumber_(_columnNumber)
{
}
MOZ_IMPLICIT ErrorData(
bool&& _isWarning,
uint32_t&& _lineNumber,
uint32_t&& _columnNumber,
nsString&& _message,
nsCString&& _filename,
nsTArray<ErrorDataNote>&& _notes) :
isWarning_(std::move(_isWarning)),
message_(std::move(_message)),
filename_(std::move(_filename)),
notes_(std::move(_notes)),
lineNumber_(std::move(_lineNumber)),
columnNumber_(std::move(_columnNumber))
{
}
bool&
isWarning()
{
return isWarning_;
}
const bool&
isWarning() const
{
return isWarning_;
}
uint32_t&
lineNumber()
{
return lineNumber_;
}
const uint32_t&
lineNumber() const
{
return lineNumber_;
}
uint32_t&
columnNumber()
{
return columnNumber_;
}
const uint32_t&
columnNumber() const
{
return columnNumber_;
}
nsString&
message()
{
return message_;
}
const nsString&
message() const
{
return message_;
}
nsCString&
filename()
{
return filename_;
}
const nsCString&
filename() const
{
return filename_;
}
nsTArray<ErrorDataNote>&
notes()
{
return notes_;
}
const nsTArray<ErrorDataNote>&
notes() const
{
return notes_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<bool> isWarning_;
::mozilla::ipc::IPDLStructMember<nsString> message_;
::mozilla::ipc::IPDLStructMember<nsCString> filename_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<ErrorDataNote>> notes_;
::mozilla::ipc::IPDLStructMember<uint32_t> lineNumber_;
::mozilla::ipc::IPDLStructMember<uint32_t> columnNumber_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::ErrorData>
{
typedef ::mozilla::dom::ErrorData 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 CSPViolation|
//
namespace mozilla {
namespace dom {
class CSPViolation 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
CSPViolation() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT CSPViolation(const nsString& _json) :
json_(_json)
{
}
MOZ_IMPLICIT CSPViolation(nsString&& _json) :
json_(std::move(_json))
{
}
nsString&
json()
{
return json_;
}
const nsString&
json() const
{
return json_;
}
private:
::mozilla::ipc::IPDLStructMember<nsString> json_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::CSPViolation>
{
typedef ::mozilla::dom::CSPViolation 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 ErrorMismatchOptions|
//
namespace mozilla {
namespace dom {
class ErrorMismatchOptions final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ErrorMismatchOptions() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
private:
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::ErrorMismatchOptions>
{
typedef ::mozilla::dom::ErrorMismatchOptions 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 ErrorValue|
//
namespace mozilla {
namespace dom {
class ErrorValue final
{
public:
enum Type {
T__None,
Tnsresult = 1,
TErrorData,
TCSPViolation,
TErrorMismatchOptions,
Tvoid_t,
T__Last = Tvoid_t
};
private:
typedef ::nsresult nsresult;
typedef ::mozilla::dom::ErrorData ErrorData;
typedef ::mozilla::dom::CSPViolation CSPViolation;
typedef ::mozilla::dom::ErrorMismatchOptions ErrorMismatchOptions;
typedef ::mozilla::void_t void_t;
typedef nsresult nsresult__tdef;
typedef ErrorData ErrorData__tdef;
typedef CSPViolation CSPViolation__tdef;
typedef ErrorMismatchOptions ErrorMismatchOptions__tdef;
typedef void_t void_t__tdef;
nsresult*
ptr_nsresult()
{
return (&(mVnsresult));
}
const nsresult*
constptr_nsresult() const
{
return (&(mVnsresult));
}
ErrorData*
ptr_ErrorData()
{
return (&(mVErrorData));
}
const ErrorData*
constptr_ErrorData() const
{
return (&(mVErrorData));
}
CSPViolation*
ptr_CSPViolation()
{
return (&(mVCSPViolation));
}
const CSPViolation*
constptr_CSPViolation() const
{
return (&(mVCSPViolation));
}
ErrorMismatchOptions*
ptr_ErrorMismatchOptions()
{
return (&(mVErrorMismatchOptions));
}
const ErrorMismatchOptions*
constptr_ErrorMismatchOptions() const
{
return (&(mVErrorMismatchOptions));
}
void_t*
ptr_void_t()
{
return (&(mVvoid_t));
}
const void_t*
constptr_void_t() const
{
return (&(mVvoid_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 ErrorValue() :
mType(T__None)
{
}
MOZ_IMPLICIT ErrorValue(const nsresult& aOther);
MOZ_IMPLICIT ErrorValue(nsresult&& aOther);
MOZ_IMPLICIT ErrorValue(const ErrorData& aOther);
MOZ_IMPLICIT ErrorValue(ErrorData&& aOther);
MOZ_IMPLICIT ErrorValue(const CSPViolation& aOther);
MOZ_IMPLICIT ErrorValue(CSPViolation&& aOther);
MOZ_IMPLICIT ErrorValue(const ErrorMismatchOptions& aOther);
MOZ_IMPLICIT ErrorValue(ErrorMismatchOptions&& aOther);
MOZ_IMPLICIT ErrorValue(const void_t& aOther);
MOZ_IMPLICIT ErrorValue(void_t&& aOther);
MOZ_IMPLICIT ErrorValue(const ErrorValue& aOther);
MOZ_IMPLICIT ErrorValue(ErrorValue&& aOther);
~ErrorValue();
Type
type() const
{
return mType;
}
ErrorValue&
operator=(const nsresult& aRhs);
ErrorValue&
operator=(nsresult&& aRhs);
ErrorValue&
operator=(const ErrorData& aRhs);
ErrorValue&
operator=(ErrorData&& aRhs);
ErrorValue&
operator=(const CSPViolation& aRhs);
ErrorValue&
operator=(CSPViolation&& aRhs);
ErrorValue&
operator=(const ErrorMismatchOptions& aRhs);
ErrorValue&
operator=(ErrorMismatchOptions&& aRhs);
ErrorValue&
operator=(const void_t& aRhs);
ErrorValue&
operator=(void_t&& aRhs);
ErrorValue&
operator=(const ErrorValue& aRhs);
ErrorValue&
operator=(ErrorValue&& 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();
}
ErrorData&
get_ErrorData()
{
AssertSanity(TErrorData);
return (*(ptr_ErrorData()));
}
const ErrorData&
get_ErrorData() const
{
AssertSanity(TErrorData);
return (*(constptr_ErrorData()));
}
operator ErrorData&()
{
return get_ErrorData();
}
operator const ErrorData&() const
{
return get_ErrorData();
}
CSPViolation&
get_CSPViolation()
{
AssertSanity(TCSPViolation);
return (*(ptr_CSPViolation()));
}
const CSPViolation&
get_CSPViolation() const
{
AssertSanity(TCSPViolation);
return (*(constptr_CSPViolation()));
}
operator CSPViolation&()
{
return get_CSPViolation();
}
operator const CSPViolation&() const
{
return get_CSPViolation();
}
ErrorMismatchOptions&
get_ErrorMismatchOptions()
{
AssertSanity(TErrorMismatchOptions);
return (*(ptr_ErrorMismatchOptions()));
}
const ErrorMismatchOptions&
get_ErrorMismatchOptions() const
{
AssertSanity(TErrorMismatchOptions);
return (*(constptr_ErrorMismatchOptions()));
}
operator ErrorMismatchOptions&()
{
return get_ErrorMismatchOptions();
}
operator const ErrorMismatchOptions&() const
{
return get_ErrorMismatchOptions();
}
void_t&
get_void_t()
{
AssertSanity(Tvoid_t);
return (*(ptr_void_t()));
}
const void_t&
get_void_t() const
{
AssertSanity(Tvoid_t);
return (*(constptr_void_t()));
}
operator void_t&()
{
return get_void_t();
}
operator const void_t&() const
{
return get_void_t();
}
private:
union {
nsresult mVnsresult;
ErrorData mVErrorData;
CSPViolation mVCSPViolation;
ErrorMismatchOptions mVErrorMismatchOptions;
void_t mVvoid_t;
};
Type mType;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::ErrorValue>
{
typedef ::mozilla::dom::ErrorValue 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 RemoteWorkerDebuggerInfo|
//
namespace mozilla {
namespace dom {
class RemoteWorkerDebuggerInfo final
{
private:
typedef ::uint32_t uint32_t;
typedef ::nsString nsString;
typedef ::uint64_t uint64_t;
typedef ::nsIPrincipal nsIPrincipal;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
RemoteWorkerDebuggerInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT RemoteWorkerDebuggerInfo(
const bool& _isChrome,
const uint32_t& _type,
const nsString& _url,
const uint64_t& _windowID,
mozilla::NotNull<nsIPrincipal*> _principal,
const uint64_t& _serviceWorkerID,
const nsString& _Id,
const nsString& _name,
const nsString& _parentId) :
isChrome_(_isChrome),
url_(_url),
principal_(_principal),
Id_(_Id),
name_(_name),
parentId_(_parentId),
windowID_(_windowID),
serviceWorkerID_(_serviceWorkerID),
type_(_type)
{
}
MOZ_IMPLICIT RemoteWorkerDebuggerInfo(
bool&& _isChrome,
uint32_t&& _type,
nsString&& _url,
uint64_t&& _windowID,
mozilla::NotNull<RefPtr<nsIPrincipal>>&& _principal,
uint64_t&& _serviceWorkerID,
nsString&& _Id,
nsString&& _name,
nsString&& _parentId) :
isChrome_(std::move(_isChrome)),
url_(std::move(_url)),
principal_(std::move(_principal)),
Id_(std::move(_Id)),
name_(std::move(_name)),
parentId_(std::move(_parentId)),
windowID_(std::move(_windowID)),
serviceWorkerID_(std::move(_serviceWorkerID)),
type_(std::move(_type))
{
}
bool&
isChrome()
{
return isChrome_;
}
const bool&
isChrome() const
{
return isChrome_;
}
uint32_t&
type()
{
return type_;
}
const uint32_t&
type() const
{
return type_;
}
nsString&
url()
{
return url_;
}
const nsString&
url() const
{
return url_;
}
uint64_t&
windowID()
{
return windowID_;
}
const uint64_t&
windowID() const
{
return windowID_;
}
mozilla::NotNull<RefPtr<nsIPrincipal>>&
principal()
{
return principal_;
}
mozilla::NotNull<nsIPrincipal*>
principal() const
{
return principal_;
}
uint64_t&
serviceWorkerID()
{
return serviceWorkerID_;
}
const uint64_t&
serviceWorkerID() const
{
return serviceWorkerID_;
}
nsString&
Id()
{
return Id_;
}
const nsString&
Id() const
{
return Id_;
}
nsString&
name()
{
return name_;
}
const nsString&
name() const
{
return name_;
}
nsString&
parentId()
{
return parentId_;
}
const nsString&
parentId() const
{
return parentId_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<bool> isChrome_;
::mozilla::ipc::IPDLStructMember<nsString> url_;
::mozilla::ipc::IPDLStructMember<mozilla::NotNull<RefPtr<nsIPrincipal>>> principal_;
::mozilla::ipc::IPDLStructMember<nsString> Id_;
::mozilla::ipc::IPDLStructMember<nsString> name_;
::mozilla::ipc::IPDLStructMember<nsString> parentId_;
::mozilla::ipc::IPDLStructMember<uint64_t> windowID_;
::mozilla::ipc::IPDLStructMember<uint64_t> serviceWorkerID_;
::mozilla::ipc::IPDLStructMember<uint32_t> type_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::RemoteWorkerDebuggerInfo>
{
typedef ::mozilla::dom::RemoteWorkerDebuggerInfo 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 RemoteWorkerDebuggerErrorInfo|
//
namespace mozilla {
namespace dom {
class RemoteWorkerDebuggerErrorInfo final
{
private:
typedef ::nsCString nsCString;
typedef ::uint32_t uint32_t;
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
RemoteWorkerDebuggerErrorInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT RemoteWorkerDebuggerErrorInfo(
const nsCString& _fileName,
const uint32_t& _lineNo,
const nsString& _message) :
fileName_(_fileName),
message_(_message),
lineNo_(_lineNo)
{
}
MOZ_IMPLICIT RemoteWorkerDebuggerErrorInfo(
nsCString&& _fileName,
uint32_t&& _lineNo,
nsString&& _message) :
fileName_(std::move(_fileName)),
message_(std::move(_message)),
lineNo_(std::move(_lineNo))
{
}
nsCString&
fileName()
{
return fileName_;
}
const nsCString&
fileName() const
{
return fileName_;
}
uint32_t&
lineNo()
{
return lineNo_;
}
const uint32_t&
lineNo() const
{
return lineNo_;
}
nsString&
message()
{
return message_;
}
const nsString&
message() const
{
return message_;
}
private:
::mozilla::ipc::IPDLStructMember<nsCString> fileName_;
::mozilla::ipc::IPDLStructMember<nsString> message_;
::mozilla::ipc::IPDLStructMember<uint32_t> lineNo_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::RemoteWorkerDebuggerErrorInfo>
{
typedef ::mozilla::dom::RemoteWorkerDebuggerErrorInfo paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
#endif // ifndef RemoteWorkerTypes_h