//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#ifndef DOMTypes_h
#define DOMTypes_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 "Units.h"
#include "mozilla/HalIPCUtils.h"
#include "mozilla/RemoteLazyInputStream.h"
#include "mozilla/ScrollbarPreferences.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/dom/BrowsingContext.h"
#include "mozilla/dom/LoadURIOptionsBinding.h"
#include "mozilla/dom/NavigationBinding.h"
#include "mozilla/dom/NotificationBinding.h"
#include "mozilla/dom/SessionHistoryEntry.h"
#include "mozilla/dom/UserNavigationInvolvement.h"
#include "mozilla/gfx/Types.h"
#include "mozilla/ipc/BigBuffer.h"
#include "mozilla/ipc/IPCStreamUtils.h"
#include "mozilla/ipc/IPDLStructMember.h"
#include "mozilla/net/ClassOfService.h"
#include "nsIClassifiedChannel.h"
#include "nsILoadInfo.h"
#include "nsIPolicyContainer.h"
#include "nsIPrincipal.h"
#include "nsIReferrerInfo.h"
#include "nsIURI.h"
#include "nsIVariant.h"
#include "nsIWidgetListener.h"
#include "nsStructuredCloneContainer.h"
#include "mozilla/dom/IPCBlob.h"
#include "mozilla/ipc/IPCStream.h"
#include "mozilla/ipc/ProtocolTypes.h"
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct MessagePortIdentifier|
//
namespace mozilla {
namespace dom {
class MessagePortIdentifier final
{
private:
typedef ::nsID nsID;
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
MessagePortIdentifier() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT MessagePortIdentifier(
const nsID& _uuid,
const nsID& _destinationUuid,
const uint32_t& _sequenceId,
const bool& _neutered) :
uuid_(_uuid),
destinationUuid_(_destinationUuid),
neutered_(_neutered),
sequenceId_(_sequenceId)
{
}
MOZ_IMPLICIT MessagePortIdentifier(
nsID&& _uuid,
nsID&& _destinationUuid,
uint32_t&& _sequenceId,
bool&& _neutered) :
uuid_(std::move(_uuid)),
destinationUuid_(std::move(_destinationUuid)),
neutered_(std::move(_neutered)),
sequenceId_(std::move(_sequenceId))
{
}
nsID&
uuid()
{
return uuid_;
}
const nsID&
uuid() const
{
return uuid_;
}
nsID&
destinationUuid()
{
return destinationUuid_;
}
const nsID&
destinationUuid() const
{
return destinationUuid_;
}
uint32_t&
sequenceId()
{
return sequenceId_;
}
const uint32_t&
sequenceId() const
{
return sequenceId_;
}
bool&
neutered()
{
return neutered_;
}
const bool&
neutered() const
{
return neutered_;
}
private:
::mozilla::ipc::IPDLStructMember<nsID> uuid_;
::mozilla::ipc::IPDLStructMember<nsID> destinationUuid_;
::mozilla::ipc::IPDLStructMember<bool> neutered_;
::mozilla::ipc::IPDLStructMember<uint32_t> sequenceId_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::MessagePortIdentifier>
{
typedef ::mozilla::dom::MessagePortIdentifier 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 ScreenDetails|
//
namespace mozilla {
namespace dom {
class ScreenDetails final
{
private:
typedef ::mozilla::LayoutDeviceIntRect LayoutDeviceIntRect;
typedef ::mozilla::DesktopIntRect DesktopIntRect;
typedef ::int32_t int32_t;
typedef ::uint32_t uint32_t;
typedef ::mozilla::DesktopToLayoutDeviceScale DesktopToLayoutDeviceScale;
typedef ::mozilla::CSSToLayoutDeviceScale CSSToLayoutDeviceScale;
typedef ::mozilla::hal::ScreenOrientation ScreenOrientation;
typedef ::uint16_t uint16_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ScreenDetails() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ScreenDetails(
const LayoutDeviceIntRect& _rect,
const DesktopIntRect& _rectDisplayPix,
const LayoutDeviceIntRect& _availRect,
const DesktopIntRect& _availRectDisplayPix,
const int32_t& _pixelDepth,
const int32_t& _colorDepth,
const uint32_t& _refreshRate,
const DesktopToLayoutDeviceScale& _contentsScaleFactor,
const CSSToLayoutDeviceScale& _defaultCSSScaleFactor,
const float& _dpi,
const ScreenOrientation& _orientation,
const uint16_t& _orientationAngle,
const bool& _isPseudoDisplay,
const bool& _isHDR) :
rect_(_rect),
rectDisplayPix_(_rectDisplayPix),
availRect_(_availRect),
availRectDisplayPix_(_availRectDisplayPix),
contentsScaleFactor_(_contentsScaleFactor),
defaultCSSScaleFactor_(_defaultCSSScaleFactor),
orientation_(_orientation),
isPseudoDisplay_(_isPseudoDisplay),
isHDR_(_isHDR),
pixelDepth_(_pixelDepth),
colorDepth_(_colorDepth),
refreshRate_(_refreshRate),
dpi_(_dpi),
orientationAngle_(_orientationAngle)
{
}
MOZ_IMPLICIT ScreenDetails(
LayoutDeviceIntRect&& _rect,
DesktopIntRect&& _rectDisplayPix,
LayoutDeviceIntRect&& _availRect,
DesktopIntRect&& _availRectDisplayPix,
int32_t&& _pixelDepth,
int32_t&& _colorDepth,
uint32_t&& _refreshRate,
DesktopToLayoutDeviceScale&& _contentsScaleFactor,
CSSToLayoutDeviceScale&& _defaultCSSScaleFactor,
float&& _dpi,
ScreenOrientation&& _orientation,
uint16_t&& _orientationAngle,
bool&& _isPseudoDisplay,
bool&& _isHDR) :
rect_(std::move(_rect)),
rectDisplayPix_(std::move(_rectDisplayPix)),
availRect_(std::move(_availRect)),
availRectDisplayPix_(std::move(_availRectDisplayPix)),
contentsScaleFactor_(std::move(_contentsScaleFactor)),
defaultCSSScaleFactor_(std::move(_defaultCSSScaleFactor)),
orientation_(std::move(_orientation)),
isPseudoDisplay_(std::move(_isPseudoDisplay)),
isHDR_(std::move(_isHDR)),
pixelDepth_(std::move(_pixelDepth)),
colorDepth_(std::move(_colorDepth)),
refreshRate_(std::move(_refreshRate)),
dpi_(std::move(_dpi)),
orientationAngle_(std::move(_orientationAngle))
{
}
LayoutDeviceIntRect&
rect()
{
return rect_;
}
const LayoutDeviceIntRect&
rect() const
{
return rect_;
}
DesktopIntRect&
rectDisplayPix()
{
return rectDisplayPix_;
}
const DesktopIntRect&
rectDisplayPix() const
{
return rectDisplayPix_;
}
LayoutDeviceIntRect&
availRect()
{
return availRect_;
}
const LayoutDeviceIntRect&
availRect() const
{
return availRect_;
}
DesktopIntRect&
availRectDisplayPix()
{
return availRectDisplayPix_;
}
const DesktopIntRect&
availRectDisplayPix() const
{
return availRectDisplayPix_;
}
int32_t&
pixelDepth()
{
return pixelDepth_;
}
const int32_t&
pixelDepth() const
{
return pixelDepth_;
}
int32_t&
colorDepth()
{
return colorDepth_;
}
const int32_t&
colorDepth() const
{
return colorDepth_;
}
uint32_t&
refreshRate()
{
return refreshRate_;
}
const uint32_t&
refreshRate() const
{
return refreshRate_;
}
DesktopToLayoutDeviceScale&
contentsScaleFactor()
{
return contentsScaleFactor_;
}
const DesktopToLayoutDeviceScale&
contentsScaleFactor() const
{
return contentsScaleFactor_;
}
CSSToLayoutDeviceScale&
defaultCSSScaleFactor()
{
return defaultCSSScaleFactor_;
}
const CSSToLayoutDeviceScale&
defaultCSSScaleFactor() const
{
return defaultCSSScaleFactor_;
}
float&
dpi()
{
return dpi_;
}
const float&
dpi() const
{
return dpi_;
}
ScreenOrientation&
orientation()
{
return orientation_;
}
const ScreenOrientation&
orientation() const
{
return orientation_;
}
uint16_t&
orientationAngle()
{
return orientationAngle_;
}
const uint16_t&
orientationAngle() const
{
return orientationAngle_;
}
bool&
isPseudoDisplay()
{
return isPseudoDisplay_;
}
const bool&
isPseudoDisplay() const
{
return isPseudoDisplay_;
}
bool&
isHDR()
{
return isHDR_;
}
const bool&
isHDR() const
{
return isHDR_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<LayoutDeviceIntRect> rect_;
::mozilla::ipc::IPDLStructMember<DesktopIntRect> rectDisplayPix_;
::mozilla::ipc::IPDLStructMember<LayoutDeviceIntRect> availRect_;
::mozilla::ipc::IPDLStructMember<DesktopIntRect> availRectDisplayPix_;
::mozilla::ipc::IPDLStructMember<DesktopToLayoutDeviceScale> contentsScaleFactor_;
::mozilla::ipc::IPDLStructMember<CSSToLayoutDeviceScale> defaultCSSScaleFactor_;
::mozilla::ipc::IPDLStructMember<ScreenOrientation> orientation_;
::mozilla::ipc::IPDLStructMember<bool> isPseudoDisplay_;
::mozilla::ipc::IPDLStructMember<bool> isHDR_;
::mozilla::ipc::IPDLStructMember<int32_t> pixelDepth_;
::mozilla::ipc::IPDLStructMember<int32_t> colorDepth_;
::mozilla::ipc::IPDLStructMember<uint32_t> refreshRate_;
::mozilla::ipc::IPDLStructMember<float> dpi_;
::mozilla::ipc::IPDLStructMember<uint16_t> orientationAngle_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::ScreenDetails>
{
typedef ::mozilla::dom::ScreenDetails 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 DimensionInfo|
//
namespace mozilla {
namespace dom {
class DimensionInfo final
{
private:
typedef ::mozilla::CSSRect CSSRect;
typedef ::mozilla::CSSSize CSSSize;
typedef ::mozilla::LayoutDeviceIntPoint LayoutDeviceIntPoint;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
DimensionInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT DimensionInfo(
const CSSRect& _rect,
const CSSSize& _size,
const LayoutDeviceIntPoint& _clientOffset,
const LayoutDeviceIntPoint& _chromeOffset) :
rect_(_rect),
size_(_size),
clientOffset_(_clientOffset),
chromeOffset_(_chromeOffset)
{
}
MOZ_IMPLICIT DimensionInfo(
CSSRect&& _rect,
CSSSize&& _size,
LayoutDeviceIntPoint&& _clientOffset,
LayoutDeviceIntPoint&& _chromeOffset) :
rect_(std::move(_rect)),
size_(std::move(_size)),
clientOffset_(std::move(_clientOffset)),
chromeOffset_(std::move(_chromeOffset))
{
}
CSSRect&
rect()
{
return rect_;
}
const CSSRect&
rect() const
{
return rect_;
}
CSSSize&
size()
{
return size_;
}
const CSSSize&
size() const
{
return size_;
}
LayoutDeviceIntPoint&
clientOffset()
{
return clientOffset_;
}
const LayoutDeviceIntPoint&
clientOffset() const
{
return clientOffset_;
}
LayoutDeviceIntPoint&
chromeOffset()
{
return chromeOffset_;
}
const LayoutDeviceIntPoint&
chromeOffset() const
{
return chromeOffset_;
}
private:
::mozilla::ipc::IPDLStructMember<CSSRect> rect_;
::mozilla::ipc::IPDLStructMember<CSSSize> size_;
::mozilla::ipc::IPDLStructMember<LayoutDeviceIntPoint> clientOffset_;
::mozilla::ipc::IPDLStructMember<LayoutDeviceIntPoint> chromeOffset_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::DimensionInfo>
{
typedef ::mozilla::dom::DimensionInfo 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 FrameScriptInfo|
//
namespace mozilla {
namespace dom {
class FrameScriptInfo 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
FrameScriptInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT FrameScriptInfo(
const nsString& _url,
const bool& _runInGlobalScope) :
url_(_url),
runInGlobalScope_(_runInGlobalScope)
{
}
MOZ_IMPLICIT FrameScriptInfo(
nsString&& _url,
bool&& _runInGlobalScope) :
url_(std::move(_url)),
runInGlobalScope_(std::move(_runInGlobalScope))
{
}
nsString&
url()
{
return url_;
}
const nsString&
url() const
{
return url_;
}
bool&
runInGlobalScope()
{
return runInGlobalScope_;
}
const bool&
runInGlobalScope() const
{
return runInGlobalScope_;
}
private:
::mozilla::ipc::IPDLStructMember<nsString> url_;
::mozilla::ipc::IPDLStructMember<bool> runInGlobalScope_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::FrameScriptInfo>
{
typedef ::mozilla::dom::FrameScriptInfo 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 CreatedWindowInfo|
//
namespace mozilla {
namespace dom {
class CreatedWindowInfo final
{
private:
typedef ::nsresult nsresult;
typedef ::mozilla::dom::FrameScriptInfo FrameScriptInfo;
typedef ::uint32_t uint32_t;
typedef ::mozilla::dom::DimensionInfo DimensionInfo;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
CreatedWindowInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT CreatedWindowInfo(
const nsresult& _rv,
const bool& _windowOpened,
const nsTArray<FrameScriptInfo>& _frameScripts,
const uint32_t& _maxTouchPoints,
const DimensionInfo& _dimensions) :
rv_(_rv),
windowOpened_(_windowOpened),
frameScripts_(_frameScripts),
dimensions_(_dimensions),
maxTouchPoints_(_maxTouchPoints)
{
}
MOZ_IMPLICIT CreatedWindowInfo(
nsresult&& _rv,
bool&& _windowOpened,
nsTArray<FrameScriptInfo>&& _frameScripts,
uint32_t&& _maxTouchPoints,
DimensionInfo&& _dimensions) :
rv_(std::move(_rv)),
windowOpened_(std::move(_windowOpened)),
frameScripts_(std::move(_frameScripts)),
dimensions_(std::move(_dimensions)),
maxTouchPoints_(std::move(_maxTouchPoints))
{
}
nsresult&
rv()
{
return rv_;
}
const nsresult&
rv() const
{
return rv_;
}
bool&
windowOpened()
{
return windowOpened_;
}
const bool&
windowOpened() const
{
return windowOpened_;
}
nsTArray<FrameScriptInfo>&
frameScripts()
{
return frameScripts_;
}
const nsTArray<FrameScriptInfo>&
frameScripts() const
{
return frameScripts_;
}
uint32_t&
maxTouchPoints()
{
return maxTouchPoints_;
}
const uint32_t&
maxTouchPoints() const
{
return maxTouchPoints_;
}
DimensionInfo&
dimensions()
{
return dimensions_;
}
const DimensionInfo&
dimensions() const
{
return dimensions_;
}
private:
::mozilla::ipc::IPDLStructMember<nsresult> rv_;
::mozilla::ipc::IPDLStructMember<bool> windowOpened_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<FrameScriptInfo>> frameScripts_;
::mozilla::ipc::IPDLStructMember<DimensionInfo> dimensions_;
::mozilla::ipc::IPDLStructMember<uint32_t> maxTouchPoints_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::CreatedWindowInfo>
{
typedef ::mozilla::dom::CreatedWindowInfo 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 DocShellLoadStateInit|
//
namespace mozilla {
namespace dom {
class DocShellLoadStateInit final
{
private:
typedef ::nsIURI nsIURI;
typedef ::nsIPrincipal nsIPrincipal;
typedef ::nsIReferrerInfo nsIReferrerInfo;
typedef ::nsIPolicyContainer nsIPolicyContainer;
typedef ::nsIInputStream nsIInputStream;
typedef ::uint64_t uint64_t;
typedef ::nsString nsString;
typedef ::nsCString nsCString;
typedef ::mozilla::dom::MaybeDiscardedBrowsingContext MaybeDiscardedBrowsingContext;
typedef ::mozilla::dom::LoadingSessionHistoryInfo LoadingSessionHistoryInfo;
typedef ::uint32_t uint32_t;
typedef ::mozilla::dom::UserNavigationInvolvement UserNavigationInvolvement;
typedef ::mozilla::net::ClassificationFlags ClassificationFlags;
typedef ::int32_t int32_t;
typedef ::mozilla::dom::NavigationHistoryBehavior NavigationHistoryBehavior;
typedef ::nsILoadInfo::SchemelessInputType SchemelessInputType;
typedef ::mozilla::dom::ForceMediaDocument ForceMediaDocument;
typedef ::nsILoadInfo::HTTPSUpgradeTelemetryType HTTPSUpgradeTelemetryType;
typedef ::nsStructuredCloneContainer nsStructuredCloneContainer;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
DocShellLoadStateInit() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT DocShellLoadStateInit(
nsIURI* _URI,
nsIURI* _OriginalURI,
nsIURI* _ResultPrincipalURI,
nsIPrincipal* _TriggeringPrincipal,
nsIReferrerInfo* _ReferrerInfo,
nsIPrincipal* _PrincipalToInherit,
nsIPrincipal* _PartitionedPrincipalToInherit,
nsIURI* _BaseURI,
nsIPolicyContainer* _PolicyContainer,
nsIInputStream* _PostDataStream,
nsIInputStream* _HeadersStream,
nsIURI* _UnstrippedURI,
const uint64_t& _LoadIdentifier,
const nsString& _Target,
const nsCString& _TypeHint,
const nsString& _FileName,
const MaybeDiscardedBrowsingContext& _SourceBrowsingContext,
const MaybeDiscardedBrowsingContext& _TargetBrowsingContext,
const nsCString& _TriggeringRemoteType,
const nsString& _SrcdocData,
const mozilla::Maybe<nsCString>& _OriginalURIString,
const mozilla::Maybe<nsCString>& _RemoteTypeOverride,
const mozilla::Maybe<LoadingSessionHistoryInfo>& _loadingSessionHistoryInfo,
const uint32_t& _LoadType,
const uint32_t& _LoadFlags,
const uint32_t& _InternalLoadFlags,
const UserNavigationInvolvement& _userNavigationInvolvement,
const uint32_t& _TriggeringSandboxFlags,
const uint64_t& _TriggeringWindowId,
const bool& _TriggeringStorageAccess,
const ClassificationFlags& _TriggeringClassificationFlags,
const mozilla::Maybe<int32_t>& _CancelContentJSEpoch,
const bool& _ResultPrincipalURIIsSome,
const bool& _KeepResultPrincipalURIIfSet,
const bool& _LoadReplace,
const bool& _InheritPrincipal,
const bool& _PrincipalIsExplicit,
const bool& _NotifiedBeforeUnloadListeners,
const bool& _ForceAllowDataURI,
const bool& _IsExemptFromHTTPSFirstMode,
const bool& _OriginalFrameSrc,
const bool& _ShouldCheckForRecursion,
const bool& _IsFormSubmission,
const bool& _FirstParty,
const bool& _HasValidUserGestureActivation,
const bool& _TextDirectiveUserActivation,
const bool& _AllowFocusMove,
const bool& _IsFromProcessingFrameAttributes,
const bool& _NeedsCompletelyLoadedDocument,
const bool& _ShouldNotForceReplaceInOnLoad,
const mozilla::Maybe<NavigationHistoryBehavior>& _HistoryBehavior,
const SchemelessInputType& _SchemelessInput,
const ForceMediaDocument& _forceMediaDocument,
const HTTPSUpgradeTelemetryType& _HttpsUpgradeTelemetry,
nsStructuredCloneContainer* _NavigationAPIState,
const bool& _ChannelInitialized,
const bool& _TryToReplaceWithSessionHistoryLoad,
const bool& _IsMetaRefresh,
const bool& _IsCaptivePortalTab,
const bool& _IsInitialAboutBlankHandlingProhibited) :
URI_(_URI),
OriginalURI_(_OriginalURI),
ResultPrincipalURI_(_ResultPrincipalURI),
TriggeringPrincipal_(_TriggeringPrincipal),
ReferrerInfo_(_ReferrerInfo),
PrincipalToInherit_(_PrincipalToInherit),
PartitionedPrincipalToInherit_(_PartitionedPrincipalToInherit),
BaseURI_(_BaseURI),
PolicyContainer_(_PolicyContainer),
PostDataStream_(_PostDataStream),
HeadersStream_(_HeadersStream),
UnstrippedURI_(_UnstrippedURI),
Target_(_Target),
TypeHint_(_TypeHint),
FileName_(_FileName),
SourceBrowsingContext_(_SourceBrowsingContext),
TargetBrowsingContext_(_TargetBrowsingContext),
TriggeringRemoteType_(_TriggeringRemoteType),
SrcdocData_(_SrcdocData),
OriginalURIString_(_OriginalURIString),
RemoteTypeOverride_(_RemoteTypeOverride),
loadingSessionHistoryInfo_(_loadingSessionHistoryInfo),
userNavigationInvolvement_(_userNavigationInvolvement),
TriggeringStorageAccess_(_TriggeringStorageAccess),
TriggeringClassificationFlags_(_TriggeringClassificationFlags),
CancelContentJSEpoch_(_CancelContentJSEpoch),
ResultPrincipalURIIsSome_(_ResultPrincipalURIIsSome),
KeepResultPrincipalURIIfSet_(_KeepResultPrincipalURIIfSet),
LoadReplace_(_LoadReplace),
InheritPrincipal_(_InheritPrincipal),
PrincipalIsExplicit_(_PrincipalIsExplicit),
NotifiedBeforeUnloadListeners_(_NotifiedBeforeUnloadListeners),
ForceAllowDataURI_(_ForceAllowDataURI),
IsExemptFromHTTPSFirstMode_(_IsExemptFromHTTPSFirstMode),
OriginalFrameSrc_(_OriginalFrameSrc),
ShouldCheckForRecursion_(_ShouldCheckForRecursion),
IsFormSubmission_(_IsFormSubmission),
FirstParty_(_FirstParty),
HasValidUserGestureActivation_(_HasValidUserGestureActivation),
TextDirectiveUserActivation_(_TextDirectiveUserActivation),
AllowFocusMove_(_AllowFocusMove),
IsFromProcessingFrameAttributes_(_IsFromProcessingFrameAttributes),
NeedsCompletelyLoadedDocument_(_NeedsCompletelyLoadedDocument),
ShouldNotForceReplaceInOnLoad_(_ShouldNotForceReplaceInOnLoad),
HistoryBehavior_(_HistoryBehavior),
SchemelessInput_(_SchemelessInput),
forceMediaDocument_(_forceMediaDocument),
HttpsUpgradeTelemetry_(_HttpsUpgradeTelemetry),
NavigationAPIState_(_NavigationAPIState),
ChannelInitialized_(_ChannelInitialized),
TryToReplaceWithSessionHistoryLoad_(_TryToReplaceWithSessionHistoryLoad),
IsMetaRefresh_(_IsMetaRefresh),
IsCaptivePortalTab_(_IsCaptivePortalTab),
IsInitialAboutBlankHandlingProhibited_(_IsInitialAboutBlankHandlingProhibited),
LoadIdentifier_(_LoadIdentifier),
TriggeringWindowId_(_TriggeringWindowId),
LoadType_(_LoadType),
LoadFlags_(_LoadFlags),
InternalLoadFlags_(_InternalLoadFlags),
TriggeringSandboxFlags_(_TriggeringSandboxFlags)
{
}
MOZ_IMPLICIT DocShellLoadStateInit(
RefPtr<nsIURI>&& _URI,
RefPtr<nsIURI>&& _OriginalURI,
RefPtr<nsIURI>&& _ResultPrincipalURI,
RefPtr<nsIPrincipal>&& _TriggeringPrincipal,
RefPtr<nsIReferrerInfo>&& _ReferrerInfo,
RefPtr<nsIPrincipal>&& _PrincipalToInherit,
RefPtr<nsIPrincipal>&& _PartitionedPrincipalToInherit,
RefPtr<nsIURI>&& _BaseURI,
RefPtr<nsIPolicyContainer>&& _PolicyContainer,
RefPtr<nsIInputStream>&& _PostDataStream,
RefPtr<nsIInputStream>&& _HeadersStream,
RefPtr<nsIURI>&& _UnstrippedURI,
uint64_t&& _LoadIdentifier,
nsString&& _Target,
nsCString&& _TypeHint,
nsString&& _FileName,
MaybeDiscardedBrowsingContext&& _SourceBrowsingContext,
MaybeDiscardedBrowsingContext&& _TargetBrowsingContext,
nsCString&& _TriggeringRemoteType,
nsString&& _SrcdocData,
mozilla::Maybe<nsCString>&& _OriginalURIString,
mozilla::Maybe<nsCString>&& _RemoteTypeOverride,
mozilla::Maybe<LoadingSessionHistoryInfo>&& _loadingSessionHistoryInfo,
uint32_t&& _LoadType,
uint32_t&& _LoadFlags,
uint32_t&& _InternalLoadFlags,
UserNavigationInvolvement&& _userNavigationInvolvement,
uint32_t&& _TriggeringSandboxFlags,
uint64_t&& _TriggeringWindowId,
bool&& _TriggeringStorageAccess,
ClassificationFlags&& _TriggeringClassificationFlags,
mozilla::Maybe<int32_t>&& _CancelContentJSEpoch,
bool&& _ResultPrincipalURIIsSome,
bool&& _KeepResultPrincipalURIIfSet,
bool&& _LoadReplace,
bool&& _InheritPrincipal,
bool&& _PrincipalIsExplicit,
bool&& _NotifiedBeforeUnloadListeners,
bool&& _ForceAllowDataURI,
bool&& _IsExemptFromHTTPSFirstMode,
bool&& _OriginalFrameSrc,
bool&& _ShouldCheckForRecursion,
bool&& _IsFormSubmission,
bool&& _FirstParty,
bool&& _HasValidUserGestureActivation,
bool&& _TextDirectiveUserActivation,
bool&& _AllowFocusMove,
bool&& _IsFromProcessingFrameAttributes,
bool&& _NeedsCompletelyLoadedDocument,
bool&& _ShouldNotForceReplaceInOnLoad,
mozilla::Maybe<NavigationHistoryBehavior>&& _HistoryBehavior,
SchemelessInputType&& _SchemelessInput,
ForceMediaDocument&& _forceMediaDocument,
HTTPSUpgradeTelemetryType&& _HttpsUpgradeTelemetry,
RefPtr<nsStructuredCloneContainer>&& _NavigationAPIState,
bool&& _ChannelInitialized,
bool&& _TryToReplaceWithSessionHistoryLoad,
bool&& _IsMetaRefresh,
bool&& _IsCaptivePortalTab,
bool&& _IsInitialAboutBlankHandlingProhibited) :
URI_(std::move(_URI)),
OriginalURI_(std::move(_OriginalURI)),
ResultPrincipalURI_(std::move(_ResultPrincipalURI)),
TriggeringPrincipal_(std::move(_TriggeringPrincipal)),
ReferrerInfo_(std::move(_ReferrerInfo)),
PrincipalToInherit_(std::move(_PrincipalToInherit)),
PartitionedPrincipalToInherit_(std::move(_PartitionedPrincipalToInherit)),
BaseURI_(std::move(_BaseURI)),
PolicyContainer_(std::move(_PolicyContainer)),
PostDataStream_(std::move(_PostDataStream)),
HeadersStream_(std::move(_HeadersStream)),
UnstrippedURI_(std::move(_UnstrippedURI)),
Target_(std::move(_Target)),
TypeHint_(std::move(_TypeHint)),
FileName_(std::move(_FileName)),
SourceBrowsingContext_(std::move(_SourceBrowsingContext)),
TargetBrowsingContext_(std::move(_TargetBrowsingContext)),
TriggeringRemoteType_(std::move(_TriggeringRemoteType)),
SrcdocData_(std::move(_SrcdocData)),
OriginalURIString_(std::move(_OriginalURIString)),
RemoteTypeOverride_(std::move(_RemoteTypeOverride)),
loadingSessionHistoryInfo_(std::move(_loadingSessionHistoryInfo)),
userNavigationInvolvement_(std::move(_userNavigationInvolvement)),
TriggeringStorageAccess_(std::move(_TriggeringStorageAccess)),
TriggeringClassificationFlags_(std::move(_TriggeringClassificationFlags)),
CancelContentJSEpoch_(std::move(_CancelContentJSEpoch)),
ResultPrincipalURIIsSome_(std::move(_ResultPrincipalURIIsSome)),
KeepResultPrincipalURIIfSet_(std::move(_KeepResultPrincipalURIIfSet)),
LoadReplace_(std::move(_LoadReplace)),
InheritPrincipal_(std::move(_InheritPrincipal)),
PrincipalIsExplicit_(std::move(_PrincipalIsExplicit)),
NotifiedBeforeUnloadListeners_(std::move(_NotifiedBeforeUnloadListeners)),
ForceAllowDataURI_(std::move(_ForceAllowDataURI)),
IsExemptFromHTTPSFirstMode_(std::move(_IsExemptFromHTTPSFirstMode)),
OriginalFrameSrc_(std::move(_OriginalFrameSrc)),
ShouldCheckForRecursion_(std::move(_ShouldCheckForRecursion)),
IsFormSubmission_(std::move(_IsFormSubmission)),
FirstParty_(std::move(_FirstParty)),
HasValidUserGestureActivation_(std::move(_HasValidUserGestureActivation)),
TextDirectiveUserActivation_(std::move(_TextDirectiveUserActivation)),
AllowFocusMove_(std::move(_AllowFocusMove)),
IsFromProcessingFrameAttributes_(std::move(_IsFromProcessingFrameAttributes)),
NeedsCompletelyLoadedDocument_(std::move(_NeedsCompletelyLoadedDocument)),
ShouldNotForceReplaceInOnLoad_(std::move(_ShouldNotForceReplaceInOnLoad)),
HistoryBehavior_(std::move(_HistoryBehavior)),
SchemelessInput_(std::move(_SchemelessInput)),
forceMediaDocument_(std::move(_forceMediaDocument)),
HttpsUpgradeTelemetry_(std::move(_HttpsUpgradeTelemetry)),
NavigationAPIState_(std::move(_NavigationAPIState)),
ChannelInitialized_(std::move(_ChannelInitialized)),
TryToReplaceWithSessionHistoryLoad_(std::move(_TryToReplaceWithSessionHistoryLoad)),
IsMetaRefresh_(std::move(_IsMetaRefresh)),
IsCaptivePortalTab_(std::move(_IsCaptivePortalTab)),
IsInitialAboutBlankHandlingProhibited_(std::move(_IsInitialAboutBlankHandlingProhibited)),
LoadIdentifier_(std::move(_LoadIdentifier)),
TriggeringWindowId_(std::move(_TriggeringWindowId)),
LoadType_(std::move(_LoadType)),
LoadFlags_(std::move(_LoadFlags)),
InternalLoadFlags_(std::move(_InternalLoadFlags)),
TriggeringSandboxFlags_(std::move(_TriggeringSandboxFlags))
{
}
RefPtr<nsIURI>&
URI()
{
return URI_;
}
nsIURI*
URI() const
{
return URI_;
}
RefPtr<nsIURI>&
OriginalURI()
{
return OriginalURI_;
}
nsIURI*
OriginalURI() const
{
return OriginalURI_;
}
RefPtr<nsIURI>&
ResultPrincipalURI()
{
return ResultPrincipalURI_;
}
nsIURI*
ResultPrincipalURI() const
{
return ResultPrincipalURI_;
}
RefPtr<nsIPrincipal>&
TriggeringPrincipal()
{
return TriggeringPrincipal_;
}
nsIPrincipal*
TriggeringPrincipal() const
{
return TriggeringPrincipal_;
}
RefPtr<nsIReferrerInfo>&
ReferrerInfo()
{
return ReferrerInfo_;
}
nsIReferrerInfo*
ReferrerInfo() const
{
return ReferrerInfo_;
}
RefPtr<nsIPrincipal>&
PrincipalToInherit()
{
return PrincipalToInherit_;
}
nsIPrincipal*
PrincipalToInherit() const
{
return PrincipalToInherit_;
}
RefPtr<nsIPrincipal>&
PartitionedPrincipalToInherit()
{
return PartitionedPrincipalToInherit_;
}
nsIPrincipal*
PartitionedPrincipalToInherit() const
{
return PartitionedPrincipalToInherit_;
}
RefPtr<nsIURI>&
BaseURI()
{
return BaseURI_;
}
nsIURI*
BaseURI() const
{
return BaseURI_;
}
RefPtr<nsIPolicyContainer>&
PolicyContainer()
{
return PolicyContainer_;
}
nsIPolicyContainer*
PolicyContainer() const
{
return PolicyContainer_;
}
RefPtr<nsIInputStream>&
PostDataStream()
{
return PostDataStream_;
}
nsIInputStream*
PostDataStream() const
{
return PostDataStream_;
}
RefPtr<nsIInputStream>&
HeadersStream()
{
return HeadersStream_;
}
nsIInputStream*
HeadersStream() const
{
return HeadersStream_;
}
RefPtr<nsIURI>&
UnstrippedURI()
{
return UnstrippedURI_;
}
nsIURI*
UnstrippedURI() const
{
return UnstrippedURI_;
}
uint64_t&
LoadIdentifier()
{
return LoadIdentifier_;
}
const uint64_t&
LoadIdentifier() const
{
return LoadIdentifier_;
}
nsString&
Target()
{
return Target_;
}
const nsString&
Target() const
{
return Target_;
}
nsCString&
TypeHint()
{
return TypeHint_;
}
const nsCString&
TypeHint() const
{
return TypeHint_;
}
nsString&
FileName()
{
return FileName_;
}
const nsString&
FileName() const
{
return FileName_;
}
MaybeDiscardedBrowsingContext&
SourceBrowsingContext()
{
return SourceBrowsingContext_;
}
const MaybeDiscardedBrowsingContext&
SourceBrowsingContext() const
{
return SourceBrowsingContext_;
}
MaybeDiscardedBrowsingContext&
TargetBrowsingContext()
{
return TargetBrowsingContext_;
}
const MaybeDiscardedBrowsingContext&
TargetBrowsingContext() const
{
return TargetBrowsingContext_;
}
nsCString&
TriggeringRemoteType()
{
return TriggeringRemoteType_;
}
const nsCString&
TriggeringRemoteType() const
{
return TriggeringRemoteType_;
}
nsString&
SrcdocData()
{
return SrcdocData_;
}
const nsString&
SrcdocData() const
{
return SrcdocData_;
}
mozilla::Maybe<nsCString>&
OriginalURIString()
{
return OriginalURIString_;
}
const mozilla::Maybe<nsCString>&
OriginalURIString() const
{
return OriginalURIString_;
}
mozilla::Maybe<nsCString>&
RemoteTypeOverride()
{
return RemoteTypeOverride_;
}
const mozilla::Maybe<nsCString>&
RemoteTypeOverride() const
{
return RemoteTypeOverride_;
}
mozilla::Maybe<LoadingSessionHistoryInfo>&
loadingSessionHistoryInfo()
{
return loadingSessionHistoryInfo_;
}
const mozilla::Maybe<LoadingSessionHistoryInfo>&
loadingSessionHistoryInfo() const
{
return loadingSessionHistoryInfo_;
}
uint32_t&
LoadType()
{
return LoadType_;
}
const uint32_t&
LoadType() const
{
return LoadType_;
}
uint32_t&
LoadFlags()
{
return LoadFlags_;
}
const uint32_t&
LoadFlags() const
{
return LoadFlags_;
}
uint32_t&
InternalLoadFlags()
{
return InternalLoadFlags_;
}
const uint32_t&
InternalLoadFlags() const
{
return InternalLoadFlags_;
}
UserNavigationInvolvement&
userNavigationInvolvement()
{
return userNavigationInvolvement_;
}
const UserNavigationInvolvement&
userNavigationInvolvement() const
{
return userNavigationInvolvement_;
}
uint32_t&
TriggeringSandboxFlags()
{
return TriggeringSandboxFlags_;
}
const uint32_t&
TriggeringSandboxFlags() const
{
return TriggeringSandboxFlags_;
}
uint64_t&
TriggeringWindowId()
{
return TriggeringWindowId_;
}
const uint64_t&
TriggeringWindowId() const
{
return TriggeringWindowId_;
}
bool&
TriggeringStorageAccess()
{
return TriggeringStorageAccess_;
}
const bool&
TriggeringStorageAccess() const
{
return TriggeringStorageAccess_;
}
ClassificationFlags&
TriggeringClassificationFlags()
{
return TriggeringClassificationFlags_;
}
const ClassificationFlags&
TriggeringClassificationFlags() const
{
return TriggeringClassificationFlags_;
}
mozilla::Maybe<int32_t>&
CancelContentJSEpoch()
{
return CancelContentJSEpoch_;
}
const mozilla::Maybe<int32_t>&
CancelContentJSEpoch() const
{
return CancelContentJSEpoch_;
}
bool&
ResultPrincipalURIIsSome()
{
return ResultPrincipalURIIsSome_;
}
const bool&
ResultPrincipalURIIsSome() const
{
return ResultPrincipalURIIsSome_;
}
bool&
KeepResultPrincipalURIIfSet()
{
return KeepResultPrincipalURIIfSet_;
}
const bool&
KeepResultPrincipalURIIfSet() const
{
return KeepResultPrincipalURIIfSet_;
}
bool&
LoadReplace()
{
return LoadReplace_;
}
const bool&
LoadReplace() const
{
return LoadReplace_;
}
bool&
InheritPrincipal()
{
return InheritPrincipal_;
}
const bool&
InheritPrincipal() const
{
return InheritPrincipal_;
}
bool&
PrincipalIsExplicit()
{
return PrincipalIsExplicit_;
}
const bool&
PrincipalIsExplicit() const
{
return PrincipalIsExplicit_;
}
bool&
NotifiedBeforeUnloadListeners()
{
return NotifiedBeforeUnloadListeners_;
}
const bool&
NotifiedBeforeUnloadListeners() const
{
return NotifiedBeforeUnloadListeners_;
}
bool&
ForceAllowDataURI()
{
return ForceAllowDataURI_;
}
const bool&
ForceAllowDataURI() const
{
return ForceAllowDataURI_;
}
bool&
IsExemptFromHTTPSFirstMode()
{
return IsExemptFromHTTPSFirstMode_;
}
const bool&
IsExemptFromHTTPSFirstMode() const
{
return IsExemptFromHTTPSFirstMode_;
}
bool&
OriginalFrameSrc()
{
return OriginalFrameSrc_;
}
const bool&
OriginalFrameSrc() const
{
return OriginalFrameSrc_;
}
bool&
ShouldCheckForRecursion()
{
return ShouldCheckForRecursion_;
}
const bool&
ShouldCheckForRecursion() const
{
return ShouldCheckForRecursion_;
}
bool&
IsFormSubmission()
{
return IsFormSubmission_;
}
const bool&
IsFormSubmission() const
{
return IsFormSubmission_;
}
bool&
FirstParty()
{
return FirstParty_;
}
const bool&
FirstParty() const
{
return FirstParty_;
}
bool&
HasValidUserGestureActivation()
{
return HasValidUserGestureActivation_;
}
const bool&
HasValidUserGestureActivation() const
{
return HasValidUserGestureActivation_;
}
bool&
TextDirectiveUserActivation()
{
return TextDirectiveUserActivation_;
}
const bool&
TextDirectiveUserActivation() const
{
return TextDirectiveUserActivation_;
}
bool&
AllowFocusMove()
{
return AllowFocusMove_;
}
const bool&
AllowFocusMove() const
{
return AllowFocusMove_;
}
bool&
IsFromProcessingFrameAttributes()
{
return IsFromProcessingFrameAttributes_;
}
const bool&
IsFromProcessingFrameAttributes() const
{
return IsFromProcessingFrameAttributes_;
}
bool&
NeedsCompletelyLoadedDocument()
{
return NeedsCompletelyLoadedDocument_;
}
const bool&
NeedsCompletelyLoadedDocument() const
{
return NeedsCompletelyLoadedDocument_;
}
bool&
ShouldNotForceReplaceInOnLoad()
{
return ShouldNotForceReplaceInOnLoad_;
}
const bool&
ShouldNotForceReplaceInOnLoad() const
{
return ShouldNotForceReplaceInOnLoad_;
}
mozilla::Maybe<NavigationHistoryBehavior>&
HistoryBehavior()
{
return HistoryBehavior_;
}
const mozilla::Maybe<NavigationHistoryBehavior>&
HistoryBehavior() const
{
return HistoryBehavior_;
}
SchemelessInputType&
SchemelessInput()
{
return SchemelessInput_;
}
const SchemelessInputType&
SchemelessInput() const
{
return SchemelessInput_;
}
ForceMediaDocument&
forceMediaDocument()
{
return forceMediaDocument_;
}
const ForceMediaDocument&
forceMediaDocument() const
{
return forceMediaDocument_;
}
HTTPSUpgradeTelemetryType&
HttpsUpgradeTelemetry()
{
return HttpsUpgradeTelemetry_;
}
const HTTPSUpgradeTelemetryType&
HttpsUpgradeTelemetry() const
{
return HttpsUpgradeTelemetry_;
}
RefPtr<nsStructuredCloneContainer>&
NavigationAPIState()
{
return NavigationAPIState_;
}
nsStructuredCloneContainer*
NavigationAPIState() const
{
return NavigationAPIState_;
}
bool&
ChannelInitialized()
{
return ChannelInitialized_;
}
const bool&
ChannelInitialized() const
{
return ChannelInitialized_;
}
bool&
TryToReplaceWithSessionHistoryLoad()
{
return TryToReplaceWithSessionHistoryLoad_;
}
const bool&
TryToReplaceWithSessionHistoryLoad() const
{
return TryToReplaceWithSessionHistoryLoad_;
}
bool&
IsMetaRefresh()
{
return IsMetaRefresh_;
}
const bool&
IsMetaRefresh() const
{
return IsMetaRefresh_;
}
bool&
IsCaptivePortalTab()
{
return IsCaptivePortalTab_;
}
const bool&
IsCaptivePortalTab() const
{
return IsCaptivePortalTab_;
}
bool&
IsInitialAboutBlankHandlingProhibited()
{
return IsInitialAboutBlankHandlingProhibited_;
}
const bool&
IsInitialAboutBlankHandlingProhibited() const
{
return IsInitialAboutBlankHandlingProhibited_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> URI_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> OriginalURI_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> ResultPrincipalURI_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIPrincipal>> TriggeringPrincipal_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIReferrerInfo>> ReferrerInfo_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIPrincipal>> PrincipalToInherit_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIPrincipal>> PartitionedPrincipalToInherit_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> BaseURI_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIPolicyContainer>> PolicyContainer_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIInputStream>> PostDataStream_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIInputStream>> HeadersStream_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> UnstrippedURI_;
::mozilla::ipc::IPDLStructMember<nsString> Target_;
::mozilla::ipc::IPDLStructMember<nsCString> TypeHint_;
::mozilla::ipc::IPDLStructMember<nsString> FileName_;
::mozilla::ipc::IPDLStructMember<MaybeDiscardedBrowsingContext> SourceBrowsingContext_;
::mozilla::ipc::IPDLStructMember<MaybeDiscardedBrowsingContext> TargetBrowsingContext_;
::mozilla::ipc::IPDLStructMember<nsCString> TriggeringRemoteType_;
::mozilla::ipc::IPDLStructMember<nsString> SrcdocData_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsCString>> OriginalURIString_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsCString>> RemoteTypeOverride_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<LoadingSessionHistoryInfo>> loadingSessionHistoryInfo_;
::mozilla::ipc::IPDLStructMember<UserNavigationInvolvement> userNavigationInvolvement_;
::mozilla::ipc::IPDLStructMember<bool> TriggeringStorageAccess_;
::mozilla::ipc::IPDLStructMember<ClassificationFlags> TriggeringClassificationFlags_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<int32_t>> CancelContentJSEpoch_;
::mozilla::ipc::IPDLStructMember<bool> ResultPrincipalURIIsSome_;
::mozilla::ipc::IPDLStructMember<bool> KeepResultPrincipalURIIfSet_;
::mozilla::ipc::IPDLStructMember<bool> LoadReplace_;
::mozilla::ipc::IPDLStructMember<bool> InheritPrincipal_;
::mozilla::ipc::IPDLStructMember<bool> PrincipalIsExplicit_;
::mozilla::ipc::IPDLStructMember<bool> NotifiedBeforeUnloadListeners_;
::mozilla::ipc::IPDLStructMember<bool> ForceAllowDataURI_;
::mozilla::ipc::IPDLStructMember<bool> IsExemptFromHTTPSFirstMode_;
::mozilla::ipc::IPDLStructMember<bool> OriginalFrameSrc_;
::mozilla::ipc::IPDLStructMember<bool> ShouldCheckForRecursion_;
::mozilla::ipc::IPDLStructMember<bool> IsFormSubmission_;
::mozilla::ipc::IPDLStructMember<bool> FirstParty_;
::mozilla::ipc::IPDLStructMember<bool> HasValidUserGestureActivation_;
::mozilla::ipc::IPDLStructMember<bool> TextDirectiveUserActivation_;
::mozilla::ipc::IPDLStructMember<bool> AllowFocusMove_;
::mozilla::ipc::IPDLStructMember<bool> IsFromProcessingFrameAttributes_;
::mozilla::ipc::IPDLStructMember<bool> NeedsCompletelyLoadedDocument_;
::mozilla::ipc::IPDLStructMember<bool> ShouldNotForceReplaceInOnLoad_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<NavigationHistoryBehavior>> HistoryBehavior_;
::mozilla::ipc::IPDLStructMember<SchemelessInputType> SchemelessInput_;
::mozilla::ipc::IPDLStructMember<ForceMediaDocument> forceMediaDocument_;
::mozilla::ipc::IPDLStructMember<HTTPSUpgradeTelemetryType> HttpsUpgradeTelemetry_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsStructuredCloneContainer>> NavigationAPIState_;
::mozilla::ipc::IPDLStructMember<bool> ChannelInitialized_;
::mozilla::ipc::IPDLStructMember<bool> TryToReplaceWithSessionHistoryLoad_;
::mozilla::ipc::IPDLStructMember<bool> IsMetaRefresh_;
::mozilla::ipc::IPDLStructMember<bool> IsCaptivePortalTab_;
::mozilla::ipc::IPDLStructMember<bool> IsInitialAboutBlankHandlingProhibited_;
::mozilla::ipc::IPDLStructMember<uint64_t> LoadIdentifier_;
::mozilla::ipc::IPDLStructMember<uint64_t> TriggeringWindowId_;
::mozilla::ipc::IPDLStructMember<uint32_t> LoadType_;
::mozilla::ipc::IPDLStructMember<uint32_t> LoadFlags_;
::mozilla::ipc::IPDLStructMember<uint32_t> InternalLoadFlags_;
::mozilla::ipc::IPDLStructMember<uint32_t> TriggeringSandboxFlags_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::DocShellLoadStateInit>
{
typedef ::mozilla::dom::DocShellLoadStateInit 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 TimedChannelInfo|
//
namespace mozilla {
namespace dom {
class TimedChannelInfo final
{
private:
typedef ::int8_t int8_t;
typedef ::mozilla::TimeStamp TimeStamp;
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
TimedChannelInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT TimedChannelInfo(
const int8_t& _redirectCount,
const int8_t& _internalRedirectCount,
const TimeStamp& _asyncOpen,
const TimeStamp& _channelCreation,
const TimeStamp& _redirectStart,
const TimeStamp& _redirectEnd,
const nsString& _initiatorType,
const bool& _allRedirectsSameOrigin,
const bool& _allRedirectsPassTimingAllowCheck,
const mozilla::Maybe<bool>& _timingAllowCheckForPrincipal,
const bool& _renderBlocking,
const TimeStamp& _launchServiceWorkerStart,
const TimeStamp& _launchServiceWorkerEnd,
const TimeStamp& _dispatchFetchEventStart,
const TimeStamp& _dispatchFetchEventEnd,
const TimeStamp& _handleFetchEventStart,
const TimeStamp& _handleFetchEventEnd,
const TimeStamp& _responseStart,
const TimeStamp& _responseEnd) :
asyncOpen_(_asyncOpen),
channelCreation_(_channelCreation),
redirectStart_(_redirectStart),
redirectEnd_(_redirectEnd),
initiatorType_(_initiatorType),
allRedirectsSameOrigin_(_allRedirectsSameOrigin),
allRedirectsPassTimingAllowCheck_(_allRedirectsPassTimingAllowCheck),
timingAllowCheckForPrincipal_(_timingAllowCheckForPrincipal),
renderBlocking_(_renderBlocking),
launchServiceWorkerStart_(_launchServiceWorkerStart),
launchServiceWorkerEnd_(_launchServiceWorkerEnd),
dispatchFetchEventStart_(_dispatchFetchEventStart),
dispatchFetchEventEnd_(_dispatchFetchEventEnd),
handleFetchEventStart_(_handleFetchEventStart),
handleFetchEventEnd_(_handleFetchEventEnd),
responseStart_(_responseStart),
responseEnd_(_responseEnd),
redirectCount_(_redirectCount),
internalRedirectCount_(_internalRedirectCount)
{
}
MOZ_IMPLICIT TimedChannelInfo(
int8_t&& _redirectCount,
int8_t&& _internalRedirectCount,
TimeStamp&& _asyncOpen,
TimeStamp&& _channelCreation,
TimeStamp&& _redirectStart,
TimeStamp&& _redirectEnd,
nsString&& _initiatorType,
bool&& _allRedirectsSameOrigin,
bool&& _allRedirectsPassTimingAllowCheck,
mozilla::Maybe<bool>&& _timingAllowCheckForPrincipal,
bool&& _renderBlocking,
TimeStamp&& _launchServiceWorkerStart,
TimeStamp&& _launchServiceWorkerEnd,
TimeStamp&& _dispatchFetchEventStart,
TimeStamp&& _dispatchFetchEventEnd,
TimeStamp&& _handleFetchEventStart,
TimeStamp&& _handleFetchEventEnd,
TimeStamp&& _responseStart,
TimeStamp&& _responseEnd) :
asyncOpen_(std::move(_asyncOpen)),
channelCreation_(std::move(_channelCreation)),
redirectStart_(std::move(_redirectStart)),
redirectEnd_(std::move(_redirectEnd)),
initiatorType_(std::move(_initiatorType)),
allRedirectsSameOrigin_(std::move(_allRedirectsSameOrigin)),
allRedirectsPassTimingAllowCheck_(std::move(_allRedirectsPassTimingAllowCheck)),
timingAllowCheckForPrincipal_(std::move(_timingAllowCheckForPrincipal)),
renderBlocking_(std::move(_renderBlocking)),
launchServiceWorkerStart_(std::move(_launchServiceWorkerStart)),
launchServiceWorkerEnd_(std::move(_launchServiceWorkerEnd)),
dispatchFetchEventStart_(std::move(_dispatchFetchEventStart)),
dispatchFetchEventEnd_(std::move(_dispatchFetchEventEnd)),
handleFetchEventStart_(std::move(_handleFetchEventStart)),
handleFetchEventEnd_(std::move(_handleFetchEventEnd)),
responseStart_(std::move(_responseStart)),
responseEnd_(std::move(_responseEnd)),
redirectCount_(std::move(_redirectCount)),
internalRedirectCount_(std::move(_internalRedirectCount))
{
}
int8_t&
redirectCount()
{
return redirectCount_;
}
const int8_t&
redirectCount() const
{
return redirectCount_;
}
int8_t&
internalRedirectCount()
{
return internalRedirectCount_;
}
const int8_t&
internalRedirectCount() const
{
return internalRedirectCount_;
}
TimeStamp&
asyncOpen()
{
return asyncOpen_;
}
const TimeStamp&
asyncOpen() const
{
return asyncOpen_;
}
TimeStamp&
channelCreation()
{
return channelCreation_;
}
const TimeStamp&
channelCreation() const
{
return channelCreation_;
}
TimeStamp&
redirectStart()
{
return redirectStart_;
}
const TimeStamp&
redirectStart() const
{
return redirectStart_;
}
TimeStamp&
redirectEnd()
{
return redirectEnd_;
}
const TimeStamp&
redirectEnd() const
{
return redirectEnd_;
}
nsString&
initiatorType()
{
return initiatorType_;
}
const nsString&
initiatorType() const
{
return initiatorType_;
}
bool&
allRedirectsSameOrigin()
{
return allRedirectsSameOrigin_;
}
const bool&
allRedirectsSameOrigin() const
{
return allRedirectsSameOrigin_;
}
bool&
allRedirectsPassTimingAllowCheck()
{
return allRedirectsPassTimingAllowCheck_;
}
const bool&
allRedirectsPassTimingAllowCheck() const
{
return allRedirectsPassTimingAllowCheck_;
}
mozilla::Maybe<bool>&
timingAllowCheckForPrincipal()
{
return timingAllowCheckForPrincipal_;
}
const mozilla::Maybe<bool>&
timingAllowCheckForPrincipal() const
{
return timingAllowCheckForPrincipal_;
}
bool&
renderBlocking()
{
return renderBlocking_;
}
const bool&
renderBlocking() const
{
return renderBlocking_;
}
TimeStamp&
launchServiceWorkerStart()
{
return launchServiceWorkerStart_;
}
const TimeStamp&
launchServiceWorkerStart() const
{
return launchServiceWorkerStart_;
}
TimeStamp&
launchServiceWorkerEnd()
{
return launchServiceWorkerEnd_;
}
const TimeStamp&
launchServiceWorkerEnd() const
{
return launchServiceWorkerEnd_;
}
TimeStamp&
dispatchFetchEventStart()
{
return dispatchFetchEventStart_;
}
const TimeStamp&
dispatchFetchEventStart() const
{
return dispatchFetchEventStart_;
}
TimeStamp&
dispatchFetchEventEnd()
{
return dispatchFetchEventEnd_;
}
const TimeStamp&
dispatchFetchEventEnd() const
{
return dispatchFetchEventEnd_;
}
TimeStamp&
handleFetchEventStart()
{
return handleFetchEventStart_;
}
const TimeStamp&
handleFetchEventStart() const
{
return handleFetchEventStart_;
}
TimeStamp&
handleFetchEventEnd()
{
return handleFetchEventEnd_;
}
const TimeStamp&
handleFetchEventEnd() const
{
return handleFetchEventEnd_;
}
TimeStamp&
responseStart()
{
return responseStart_;
}
const TimeStamp&
responseStart() const
{
return responseStart_;
}
TimeStamp&
responseEnd()
{
return responseEnd_;
}
const TimeStamp&
responseEnd() const
{
return responseEnd_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<TimeStamp> asyncOpen_;
::mozilla::ipc::IPDLStructMember<TimeStamp> channelCreation_;
::mozilla::ipc::IPDLStructMember<TimeStamp> redirectStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> redirectEnd_;
::mozilla::ipc::IPDLStructMember<nsString> initiatorType_;
::mozilla::ipc::IPDLStructMember<bool> allRedirectsSameOrigin_;
::mozilla::ipc::IPDLStructMember<bool> allRedirectsPassTimingAllowCheck_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<bool>> timingAllowCheckForPrincipal_;
::mozilla::ipc::IPDLStructMember<bool> renderBlocking_;
::mozilla::ipc::IPDLStructMember<TimeStamp> launchServiceWorkerStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> launchServiceWorkerEnd_;
::mozilla::ipc::IPDLStructMember<TimeStamp> dispatchFetchEventStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> dispatchFetchEventEnd_;
::mozilla::ipc::IPDLStructMember<TimeStamp> handleFetchEventStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> handleFetchEventEnd_;
::mozilla::ipc::IPDLStructMember<TimeStamp> responseStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> responseEnd_;
::mozilla::ipc::IPDLStructMember<int8_t> redirectCount_;
::mozilla::ipc::IPDLStructMember<int8_t> internalRedirectCount_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::TimedChannelInfo>
{
typedef ::mozilla::dom::TimedChannelInfo 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 ReplacementChannelConfigInit|
//
namespace mozilla {
namespace dom {
class ReplacementChannelConfigInit final
{
private:
typedef ::uint32_t uint32_t;
typedef ::mozilla::net::ClassOfService ClassOfService;
typedef ::nsCString nsCString;
typedef ::nsIReferrerInfo nsIReferrerInfo;
typedef ::mozilla::dom::TimedChannelInfo TimedChannelInfo;
typedef ::mozilla::RemoteLazyInputStream RemoteLazyInputStream;
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
ReplacementChannelConfigInit() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ReplacementChannelConfigInit(
const uint32_t& _redirectFlags,
const ClassOfService& _classOfService,
const mozilla::Maybe<bool>& _privateBrowsing,
const mozilla::Maybe<nsCString>& _method,
nsIReferrerInfo* _referrerInfo,
const mozilla::Maybe<TimedChannelInfo>& _timedChannelInfo,
RemoteLazyInputStream* _uploadStream,
const uint64_t& _uploadStreamLength,
const bool& _uploadStreamHasHeaders,
const mozilla::Maybe<nsCString>& _contentType,
const mozilla::Maybe<nsCString>& _contentLength) :
classOfService_(_classOfService),
privateBrowsing_(_privateBrowsing),
method_(_method),
referrerInfo_(_referrerInfo),
timedChannelInfo_(_timedChannelInfo),
uploadStream_(_uploadStream),
uploadStreamHasHeaders_(_uploadStreamHasHeaders),
contentType_(_contentType),
contentLength_(_contentLength),
uploadStreamLength_(_uploadStreamLength),
redirectFlags_(_redirectFlags)
{
}
MOZ_IMPLICIT ReplacementChannelConfigInit(
uint32_t&& _redirectFlags,
ClassOfService&& _classOfService,
mozilla::Maybe<bool>&& _privateBrowsing,
mozilla::Maybe<nsCString>&& _method,
RefPtr<nsIReferrerInfo>&& _referrerInfo,
mozilla::Maybe<TimedChannelInfo>&& _timedChannelInfo,
RefPtr<RemoteLazyInputStream>&& _uploadStream,
uint64_t&& _uploadStreamLength,
bool&& _uploadStreamHasHeaders,
mozilla::Maybe<nsCString>&& _contentType,
mozilla::Maybe<nsCString>&& _contentLength) :
classOfService_(std::move(_classOfService)),
privateBrowsing_(std::move(_privateBrowsing)),
method_(std::move(_method)),
referrerInfo_(std::move(_referrerInfo)),
timedChannelInfo_(std::move(_timedChannelInfo)),
uploadStream_(std::move(_uploadStream)),
uploadStreamHasHeaders_(std::move(_uploadStreamHasHeaders)),
contentType_(std::move(_contentType)),
contentLength_(std::move(_contentLength)),
uploadStreamLength_(std::move(_uploadStreamLength)),
redirectFlags_(std::move(_redirectFlags))
{
}
uint32_t&
redirectFlags()
{
return redirectFlags_;
}
const uint32_t&
redirectFlags() const
{
return redirectFlags_;
}
ClassOfService&
classOfService()
{
return classOfService_;
}
const ClassOfService&
classOfService() const
{
return classOfService_;
}
mozilla::Maybe<bool>&
privateBrowsing()
{
return privateBrowsing_;
}
const mozilla::Maybe<bool>&
privateBrowsing() const
{
return privateBrowsing_;
}
mozilla::Maybe<nsCString>&
method()
{
return method_;
}
const mozilla::Maybe<nsCString>&
method() const
{
return method_;
}
RefPtr<nsIReferrerInfo>&
referrerInfo()
{
return referrerInfo_;
}
nsIReferrerInfo*
referrerInfo() const
{
return referrerInfo_;
}
mozilla::Maybe<TimedChannelInfo>&
timedChannelInfo()
{
return timedChannelInfo_;
}
const mozilla::Maybe<TimedChannelInfo>&
timedChannelInfo() const
{
return timedChannelInfo_;
}
RefPtr<RemoteLazyInputStream>&
uploadStream()
{
return uploadStream_;
}
RemoteLazyInputStream*
uploadStream() const
{
return uploadStream_;
}
uint64_t&
uploadStreamLength()
{
return uploadStreamLength_;
}
const uint64_t&
uploadStreamLength() const
{
return uploadStreamLength_;
}
bool&
uploadStreamHasHeaders()
{
return uploadStreamHasHeaders_;
}
const bool&
uploadStreamHasHeaders() const
{
return uploadStreamHasHeaders_;
}
mozilla::Maybe<nsCString>&
contentType()
{
return contentType_;
}
const mozilla::Maybe<nsCString>&
contentType() const
{
return contentType_;
}
mozilla::Maybe<nsCString>&
contentLength()
{
return contentLength_;
}
const mozilla::Maybe<nsCString>&
contentLength() const
{
return contentLength_;
}
private:
::mozilla::ipc::IPDLStructMember<ClassOfService> classOfService_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<bool>> privateBrowsing_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsCString>> method_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIReferrerInfo>> referrerInfo_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<TimedChannelInfo>> timedChannelInfo_;
::mozilla::ipc::IPDLStructMember<RefPtr<RemoteLazyInputStream>> uploadStream_;
::mozilla::ipc::IPDLStructMember<bool> uploadStreamHasHeaders_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsCString>> contentType_;
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsCString>> contentLength_;
::mozilla::ipc::IPDLStructMember<uint64_t> uploadStreamLength_;
::mozilla::ipc::IPDLStructMember<uint32_t> redirectFlags_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::ReplacementChannelConfigInit>
{
typedef ::mozilla::dom::ReplacementChannelConfigInit 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 IPDLVariantValue|
//
namespace mozilla {
namespace dom {
class IPDLVariantValue final
{
public:
enum Type {
T__None,
Tbool = 1,
Tuint8_t,
Tint16_t,
Tuint16_t,
Tint32_t,
Tuint32_t,
Tfloat,
Tdouble,
TnsID,
TnsString,
TnsCString,
TnsIURI,
TnsIPrincipal,
T__Last = TnsIPrincipal
};
private:
typedef ::uint8_t uint8_t;
typedef ::int16_t int16_t;
typedef ::uint16_t uint16_t;
typedef ::int32_t int32_t;
typedef ::uint32_t uint32_t;
typedef ::nsID nsID;
typedef ::nsString nsString;
typedef ::nsCString nsCString;
typedef ::nsIURI nsIURI;
typedef ::nsIPrincipal nsIPrincipal;
typedef bool bool__tdef;
typedef uint8_t uint8_t__tdef;
typedef int16_t int16_t__tdef;
typedef uint16_t uint16_t__tdef;
typedef int32_t int32_t__tdef;
typedef uint32_t uint32_t__tdef;
typedef float float__tdef;
typedef double double__tdef;
typedef nsID nsID__tdef;
typedef nsString nsString__tdef;
typedef nsCString nsCString__tdef;
typedef RefPtr<nsIURI> nsIURI__tdef;
typedef RefPtr<nsIPrincipal> nsIPrincipal__tdef;
bool*
ptr_bool()
{
return (&(mVbool));
}
const bool*
constptr_bool() const
{
return (&(mVbool));
}
uint8_t*
ptr_uint8_t()
{
return (&(mVuint8_t));
}
const uint8_t*
constptr_uint8_t() const
{
return (&(mVuint8_t));
}
int16_t*
ptr_int16_t()
{
return (&(mVint16_t));
}
const int16_t*
constptr_int16_t() const
{
return (&(mVint16_t));
}
uint16_t*
ptr_uint16_t()
{
return (&(mVuint16_t));
}
const uint16_t*
constptr_uint16_t() const
{
return (&(mVuint16_t));
}
int32_t*
ptr_int32_t()
{
return (&(mVint32_t));
}
const int32_t*
constptr_int32_t() const
{
return (&(mVint32_t));
}
uint32_t*
ptr_uint32_t()
{
return (&(mVuint32_t));
}
const uint32_t*
constptr_uint32_t() const
{
return (&(mVuint32_t));
}
float*
ptr_float()
{
return (&(mVfloat));
}
const float*
constptr_float() const
{
return (&(mVfloat));
}
double*
ptr_double()
{
return (&(mVdouble));
}
const double*
constptr_double() const
{
return (&(mVdouble));
}
nsID*
ptr_nsID()
{
return (&(mVnsID));
}
const nsID*
constptr_nsID() const
{
return (&(mVnsID));
}
nsString*
ptr_nsString()
{
return (&(mVnsString));
}
const nsString*
constptr_nsString() const
{
return (&(mVnsString));
}
nsCString*
ptr_nsCString()
{
return (&(mVnsCString));
}
const nsCString*
constptr_nsCString() const
{
return (&(mVnsCString));
}
RefPtr<nsIURI>*
ptr_nsIURI()
{
return (&(mVnsIURI));
}
const RefPtr<nsIURI>*
constptr_nsIURI() const
{
return (&(mVnsIURI));
}
RefPtr<nsIPrincipal>*
ptr_nsIPrincipal()
{
return (&(mVnsIPrincipal));
}
const RefPtr<nsIPrincipal>*
constptr_nsIPrincipal() const
{
return (&(mVnsIPrincipal));
}
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 IPDLVariantValue() :
mType(T__None)
{
}
MOZ_IMPLICIT IPDLVariantValue(const bool& aOther);
MOZ_IMPLICIT IPDLVariantValue(bool&& aOther);
MOZ_IMPLICIT IPDLVariantValue(const uint8_t& aOther);
MOZ_IMPLICIT IPDLVariantValue(uint8_t&& aOther);
MOZ_IMPLICIT IPDLVariantValue(const int16_t& aOther);
MOZ_IMPLICIT IPDLVariantValue(int16_t&& aOther);
MOZ_IMPLICIT IPDLVariantValue(const uint16_t& aOther);
MOZ_IMPLICIT IPDLVariantValue(uint16_t&& aOther);
MOZ_IMPLICIT IPDLVariantValue(const int32_t& aOther);
MOZ_IMPLICIT IPDLVariantValue(int32_t&& aOther);
MOZ_IMPLICIT IPDLVariantValue(const uint32_t& aOther);
MOZ_IMPLICIT IPDLVariantValue(uint32_t&& aOther);
MOZ_IMPLICIT IPDLVariantValue(const float& aOther);
MOZ_IMPLICIT IPDLVariantValue(float&& aOther);
MOZ_IMPLICIT IPDLVariantValue(const double& aOther);
MOZ_IMPLICIT IPDLVariantValue(double&& aOther);
MOZ_IMPLICIT IPDLVariantValue(const nsID& aOther);
MOZ_IMPLICIT IPDLVariantValue(nsID&& aOther);
MOZ_IMPLICIT IPDLVariantValue(const nsString& aOther);
MOZ_IMPLICIT IPDLVariantValue(nsString&& aOther);
MOZ_IMPLICIT IPDLVariantValue(const nsCString& aOther);
MOZ_IMPLICIT IPDLVariantValue(nsCString&& aOther);
MOZ_IMPLICIT IPDLVariantValue(nsIURI* aOther);
MOZ_IMPLICIT IPDLVariantValue(RefPtr<nsIURI>&& aOther);
MOZ_IMPLICIT IPDLVariantValue(nsIPrincipal* aOther);
MOZ_IMPLICIT IPDLVariantValue(RefPtr<nsIPrincipal>&& aOther);
MOZ_IMPLICIT IPDLVariantValue(const IPDLVariantValue& aOther);
MOZ_IMPLICIT IPDLVariantValue(IPDLVariantValue&& aOther);
~IPDLVariantValue();
Type
type() const
{
return mType;
}
IPDLVariantValue&
operator=(const bool& aRhs);
IPDLVariantValue&
operator=(bool&& aRhs);
IPDLVariantValue&
operator=(const uint8_t& aRhs);
IPDLVariantValue&
operator=(uint8_t&& aRhs);
IPDLVariantValue&
operator=(const int16_t& aRhs);
IPDLVariantValue&
operator=(int16_t&& aRhs);
IPDLVariantValue&
operator=(const uint16_t& aRhs);
IPDLVariantValue&
operator=(uint16_t&& aRhs);
IPDLVariantValue&
operator=(const int32_t& aRhs);
IPDLVariantValue&
operator=(int32_t&& aRhs);
IPDLVariantValue&
operator=(const uint32_t& aRhs);
IPDLVariantValue&
operator=(uint32_t&& aRhs);
IPDLVariantValue&
operator=(const float& aRhs);
IPDLVariantValue&
operator=(float&& aRhs);
IPDLVariantValue&
operator=(const double& aRhs);
IPDLVariantValue&
operator=(double&& aRhs);
IPDLVariantValue&
operator=(const nsID& aRhs);
IPDLVariantValue&
operator=(nsID&& aRhs);
IPDLVariantValue&
operator=(const nsString& aRhs);
IPDLVariantValue&
operator=(nsString&& aRhs);
IPDLVariantValue&
operator=(const nsCString& aRhs);
IPDLVariantValue&
operator=(nsCString&& aRhs);
IPDLVariantValue&
operator=(nsIURI* aRhs);
IPDLVariantValue&
operator=(RefPtr<nsIURI>&& aRhs);
IPDLVariantValue&
operator=(nsIPrincipal* aRhs);
IPDLVariantValue&
operator=(RefPtr<nsIPrincipal>&& aRhs);
IPDLVariantValue&
operator=(const IPDLVariantValue& aRhs);
IPDLVariantValue&
operator=(IPDLVariantValue&& aRhs);
bool&
get_bool()
{
AssertSanity(Tbool);
return (*(ptr_bool()));
}
const bool&
get_bool() const
{
AssertSanity(Tbool);
return (*(constptr_bool()));
}
operator bool&()
{
return get_bool();
}
operator const bool&() const
{
return get_bool();
}
uint8_t&
get_uint8_t()
{
AssertSanity(Tuint8_t);
return (*(ptr_uint8_t()));
}
const uint8_t&
get_uint8_t() const
{
AssertSanity(Tuint8_t);
return (*(constptr_uint8_t()));
}
operator uint8_t&()
{
return get_uint8_t();
}
operator const uint8_t&() const
{
return get_uint8_t();
}
int16_t&
get_int16_t()
{
AssertSanity(Tint16_t);
return (*(ptr_int16_t()));
}
const int16_t&
get_int16_t() const
{
AssertSanity(Tint16_t);
return (*(constptr_int16_t()));
}
operator int16_t&()
{
return get_int16_t();
}
operator const int16_t&() const
{
return get_int16_t();
}
uint16_t&
get_uint16_t()
{
AssertSanity(Tuint16_t);
return (*(ptr_uint16_t()));
}
const uint16_t&
get_uint16_t() const
{
AssertSanity(Tuint16_t);
return (*(constptr_uint16_t()));
}
operator uint16_t&()
{
return get_uint16_t();
}
operator const uint16_t&() const
{
return get_uint16_t();
}
int32_t&
get_int32_t()
{
AssertSanity(Tint32_t);
return (*(ptr_int32_t()));
}
const int32_t&
get_int32_t() const
{
AssertSanity(Tint32_t);
return (*(constptr_int32_t()));
}
operator int32_t&()
{
return get_int32_t();
}
operator const int32_t&() const
{
return get_int32_t();
}
uint32_t&
get_uint32_t()
{
AssertSanity(Tuint32_t);
return (*(ptr_uint32_t()));
}
const uint32_t&
get_uint32_t() const
{
AssertSanity(Tuint32_t);
return (*(constptr_uint32_t()));
}
operator uint32_t&()
{
return get_uint32_t();
}
operator const uint32_t&() const
{
return get_uint32_t();
}
float&
get_float()
{
AssertSanity(Tfloat);
return (*(ptr_float()));
}
const float&
get_float() const
{
AssertSanity(Tfloat);
return (*(constptr_float()));
}
operator float&()
{
return get_float();
}
operator const float&() const
{
return get_float();
}
double&
get_double()
{
AssertSanity(Tdouble);
return (*(ptr_double()));
}
const double&
get_double() const
{
AssertSanity(Tdouble);
return (*(constptr_double()));
}
operator double&()
{
return get_double();
}
operator const double&() const
{
return get_double();
}
nsID&
get_nsID()
{
AssertSanity(TnsID);
return (*(ptr_nsID()));
}
const nsID&
get_nsID() const
{
AssertSanity(TnsID);
return (*(constptr_nsID()));
}
operator nsID&()
{
return get_nsID();
}
operator const nsID&() const
{
return get_nsID();
}
nsString&
get_nsString()
{
AssertSanity(TnsString);
return (*(ptr_nsString()));
}
const nsString&
get_nsString() const
{
AssertSanity(TnsString);
return (*(constptr_nsString()));
}
operator nsString&()
{
return get_nsString();
}
operator const nsString&() const
{
return get_nsString();
}
nsCString&
get_nsCString()
{
AssertSanity(TnsCString);
return (*(ptr_nsCString()));
}
const nsCString&
get_nsCString() const
{
AssertSanity(TnsCString);
return (*(constptr_nsCString()));
}
operator nsCString&()
{
return get_nsCString();
}
operator const nsCString&() const
{
return get_nsCString();
}
RefPtr<nsIURI>&
get_nsIURI()
{
AssertSanity(TnsIURI);
return (*(ptr_nsIURI()));
}
nsIURI*
get_nsIURI() const
{
AssertSanity(TnsIURI);
return (*(constptr_nsIURI()));
}
operator RefPtr<nsIURI>&()
{
return get_nsIURI();
}
operator nsIURI*() const
{
return get_nsIURI();
}
RefPtr<nsIPrincipal>&
get_nsIPrincipal()
{
AssertSanity(TnsIPrincipal);
return (*(ptr_nsIPrincipal()));
}
nsIPrincipal*
get_nsIPrincipal() const
{
AssertSanity(TnsIPrincipal);
return (*(constptr_nsIPrincipal()));
}
operator RefPtr<nsIPrincipal>&()
{
return get_nsIPrincipal();
}
operator nsIPrincipal*() const
{
return get_nsIPrincipal();
}
private:
union {
bool mVbool;
uint8_t mVuint8_t;
int16_t mVint16_t;
uint16_t mVuint16_t;
int32_t mVint32_t;
uint32_t mVuint32_t;
float mVfloat;
double mVdouble;
nsID mVnsID;
nsString mVnsString;
nsCString mVnsCString;
RefPtr<nsIURI> mVnsIURI;
RefPtr<nsIPrincipal> mVnsIPrincipal;
};
Type mType;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPDLVariantValue>
{
typedef ::mozilla::dom::IPDLVariantValue 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 IDPLVariant|
//
namespace mozilla {
namespace dom {
class IDPLVariant final
{
private:
typedef ::uint32_t uint32_t;
typedef ::mozilla::dom::IPDLVariantValue IPDLVariantValue;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
IDPLVariant() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT IDPLVariant(
const uint32_t& _type,
const IPDLVariantValue& _data) :
data_(_data),
type_(_type)
{
}
MOZ_IMPLICIT IDPLVariant(
uint32_t&& _type,
IPDLVariantValue&& _data) :
data_(std::move(_data)),
type_(std::move(_type))
{
}
uint32_t&
type()
{
return type_;
}
const uint32_t&
type() const
{
return type_;
}
IPDLVariantValue&
data()
{
return data_;
}
const IPDLVariantValue&
data() const
{
return data_;
}
private:
::mozilla::ipc::IPDLStructMember<IPDLVariantValue> data_;
::mozilla::ipc::IPDLStructMember<uint32_t> type_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IDPLVariant>
{
typedef ::mozilla::dom::IDPLVariant 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 IPDLProperty|
//
namespace mozilla {
namespace dom {
class IPDLProperty final
{
private:
typedef ::nsString nsString;
typedef ::nsIVariant nsIVariant;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
IPDLProperty() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT IPDLProperty(
const nsString& _name,
nsIVariant* _value) :
name_(_name),
value_(_value)
{
}
MOZ_IMPLICIT IPDLProperty(
nsString&& _name,
RefPtr<nsIVariant>&& _value) :
name_(std::move(_name)),
value_(std::move(_value))
{
}
nsString&
name()
{
return name_;
}
const nsString&
name() const
{
return name_;
}
RefPtr<nsIVariant>&
value()
{
return value_;
}
nsIVariant*
value() const
{
return value_;
}
private:
::mozilla::ipc::IPDLStructMember<nsString> name_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIVariant>> value_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPDLProperty>
{
typedef ::mozilla::dom::IPDLProperty 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 ParentShowInfo|
//
namespace mozilla {
namespace dom {
class ParentShowInfo final
{
private:
typedef ::nsString nsString;
typedef ::int32_t int32_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ParentShowInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ParentShowInfo(
const nsString& _name,
const bool& _fakeShowInfo,
const bool& _isTransparent,
const float& _dpi,
const int32_t& _widgetRounding,
const double& _defaultScale,
const double& _desktopToDeviceScale) :
name_(_name),
fakeShowInfo_(_fakeShowInfo),
isTransparent_(_isTransparent),
defaultScale_(_defaultScale),
desktopToDeviceScale_(_desktopToDeviceScale),
dpi_(_dpi),
widgetRounding_(_widgetRounding)
{
}
MOZ_IMPLICIT ParentShowInfo(
nsString&& _name,
bool&& _fakeShowInfo,
bool&& _isTransparent,
float&& _dpi,
int32_t&& _widgetRounding,
double&& _defaultScale,
double&& _desktopToDeviceScale) :
name_(std::move(_name)),
fakeShowInfo_(std::move(_fakeShowInfo)),
isTransparent_(std::move(_isTransparent)),
defaultScale_(std::move(_defaultScale)),
desktopToDeviceScale_(std::move(_desktopToDeviceScale)),
dpi_(std::move(_dpi)),
widgetRounding_(std::move(_widgetRounding))
{
}
nsString&
name()
{
return name_;
}
const nsString&
name() const
{
return name_;
}
bool&
fakeShowInfo()
{
return fakeShowInfo_;
}
const bool&
fakeShowInfo() const
{
return fakeShowInfo_;
}
bool&
isTransparent()
{
return isTransparent_;
}
const bool&
isTransparent() const
{
return isTransparent_;
}
float&
dpi()
{
return dpi_;
}
const float&
dpi() const
{
return dpi_;
}
int32_t&
widgetRounding()
{
return widgetRounding_;
}
const int32_t&
widgetRounding() const
{
return widgetRounding_;
}
double&
defaultScale()
{
return defaultScale_;
}
const double&
defaultScale() const
{
return defaultScale_;
}
double&
desktopToDeviceScale()
{
return desktopToDeviceScale_;
}
const double&
desktopToDeviceScale() const
{
return desktopToDeviceScale_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<nsString> name_;
::mozilla::ipc::IPDLStructMember<bool> fakeShowInfo_;
::mozilla::ipc::IPDLStructMember<bool> isTransparent_;
::mozilla::ipc::IPDLStructMember<double> defaultScale_;
::mozilla::ipc::IPDLStructMember<double> desktopToDeviceScale_;
::mozilla::ipc::IPDLStructMember<float> dpi_;
::mozilla::ipc::IPDLStructMember<int32_t> widgetRounding_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::ParentShowInfo>
{
typedef ::mozilla::dom::ParentShowInfo 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 OwnerShowInfo|
//
namespace mozilla {
namespace dom {
class OwnerShowInfo final
{
private:
typedef ::mozilla::LayoutDeviceIntSize LayoutDeviceIntSize;
typedef ::mozilla::ScrollbarPreference ScrollbarPreference;
typedef ::nsSizeMode nsSizeMode;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
OwnerShowInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT OwnerShowInfo(
const LayoutDeviceIntSize& _size,
const ScrollbarPreference& _scrollbarPreference,
const nsSizeMode& _sizeMode) :
size_(_size),
scrollbarPreference_(_scrollbarPreference),
sizeMode_(_sizeMode)
{
}
MOZ_IMPLICIT OwnerShowInfo(
LayoutDeviceIntSize&& _size,
ScrollbarPreference&& _scrollbarPreference,
nsSizeMode&& _sizeMode) :
size_(std::move(_size)),
scrollbarPreference_(std::move(_scrollbarPreference)),
sizeMode_(std::move(_sizeMode))
{
}
LayoutDeviceIntSize&
size()
{
return size_;
}
const LayoutDeviceIntSize&
size() const
{
return size_;
}
ScrollbarPreference&
scrollbarPreference()
{
return scrollbarPreference_;
}
const ScrollbarPreference&
scrollbarPreference() const
{
return scrollbarPreference_;
}
nsSizeMode&
sizeMode()
{
return sizeMode_;
}
const nsSizeMode&
sizeMode() const
{
return sizeMode_;
}
private:
::mozilla::ipc::IPDLStructMember<LayoutDeviceIntSize> size_;
::mozilla::ipc::IPDLStructMember<ScrollbarPreference> scrollbarPreference_;
::mozilla::ipc::IPDLStructMember<nsSizeMode> sizeMode_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::OwnerShowInfo>
{
typedef ::mozilla::dom::OwnerShowInfo 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 IPCImage|
//
namespace mozilla {
namespace dom {
class IPCImage final
{
private:
typedef ::mozilla::ipc::BigBuffer BigBuffer;
typedef ::uint32_t uint32_t;
typedef ::mozilla::gfx::SurfaceFormat SurfaceFormat;
typedef ::mozilla::ImageIntSize ImageIntSize;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
IPCImage() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT IPCImage(
BigBuffer&& _data,
const uint32_t& _stride,
const SurfaceFormat& _format,
const ImageIntSize& _size) :
data_(std::move(_data)),
format_(_format),
size_(_size),
stride_(_stride)
{
}
MOZ_IMPLICIT IPCImage(
BigBuffer&& _data,
uint32_t&& _stride,
SurfaceFormat&& _format,
ImageIntSize&& _size) :
data_(std::move(_data)),
format_(std::move(_format)),
size_(std::move(_size)),
stride_(std::move(_stride))
{
}
BigBuffer&
data()
{
return data_;
}
const BigBuffer&
data() const
{
return data_;
}
uint32_t&
stride()
{
return stride_;
}
const uint32_t&
stride() const
{
return stride_;
}
SurfaceFormat&
format()
{
return format_;
}
const SurfaceFormat&
format() const
{
return format_;
}
ImageIntSize&
size()
{
return size_;
}
const ImageIntSize&
size() const
{
return size_;
}
private:
::mozilla::ipc::IPDLStructMember<BigBuffer> data_;
::mozilla::ipc::IPDLStructMember<SurfaceFormat> format_;
::mozilla::ipc::IPDLStructMember<ImageIntSize> size_;
::mozilla::ipc::IPDLStructMember<uint32_t> stride_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCImage>
{
typedef ::mozilla::dom::IPCImage paramType;
static void
Write(
IPC::MessageWriter* aWriter,
paramType&& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct IPCNotificationAction|
//
namespace mozilla {
namespace dom {
class IPCNotificationAction 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
IPCNotificationAction() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT IPCNotificationAction(
const nsString& _name,
const nsString& _title) :
name_(_name),
title_(_title)
{
}
MOZ_IMPLICIT IPCNotificationAction(
nsString&& _name,
nsString&& _title) :
name_(std::move(_name)),
title_(std::move(_title))
{
}
nsString&
name()
{
return name_;
}
const nsString&
name() const
{
return name_;
}
nsString&
title()
{
return title_;
}
const nsString&
title() const
{
return title_;
}
private:
::mozilla::ipc::IPDLStructMember<nsString> name_;
::mozilla::ipc::IPDLStructMember<nsString> title_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCNotificationAction>
{
typedef ::mozilla::dom::IPCNotificationAction 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 IPCNotificationOptions|
//
namespace mozilla {
namespace dom {
class IPCNotificationOptions final
{
private:
typedef ::nsString nsString;
typedef ::mozilla::dom::NotificationDirection NotificationDirection;
typedef ::nsIURI nsIURI;
typedef ::uint32_t uint32_t;
typedef ::mozilla::dom::IPCNotificationAction IPCNotificationAction;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
IPCNotificationOptions() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT IPCNotificationOptions(
const nsString& _title,
const NotificationDirection& _dir,
const nsString& _lang,
const nsString& _body,
const nsString& _tag,
nsIURI* _icon,
const bool& _requireInteraction,
const bool& _silent,
const nsTArray<uint32_t>& _vibrate,
const nsString& _dataSerialized,
const nsTArray<IPCNotificationAction>& _actions) :
title_(_title),
dir_(_dir),
lang_(_lang),
body_(_body),
tag_(_tag),
icon_(_icon),
requireInteraction_(_requireInteraction),
silent_(_silent),
vibrate_(_vibrate),
dataSerialized_(_dataSerialized),
actions_(_actions)
{
}
MOZ_IMPLICIT IPCNotificationOptions(
nsString&& _title,
NotificationDirection&& _dir,
nsString&& _lang,
nsString&& _body,
nsString&& _tag,
RefPtr<nsIURI>&& _icon,
bool&& _requireInteraction,
bool&& _silent,
nsTArray<uint32_t>&& _vibrate,
nsString&& _dataSerialized,
nsTArray<IPCNotificationAction>&& _actions) :
title_(std::move(_title)),
dir_(std::move(_dir)),
lang_(std::move(_lang)),
body_(std::move(_body)),
tag_(std::move(_tag)),
icon_(std::move(_icon)),
requireInteraction_(std::move(_requireInteraction)),
silent_(std::move(_silent)),
vibrate_(std::move(_vibrate)),
dataSerialized_(std::move(_dataSerialized)),
actions_(std::move(_actions))
{
}
nsString&
title()
{
return title_;
}
const nsString&
title() const
{
return title_;
}
NotificationDirection&
dir()
{
return dir_;
}
const NotificationDirection&
dir() const
{
return dir_;
}
nsString&
lang()
{
return lang_;
}
const nsString&
lang() const
{
return lang_;
}
nsString&
body()
{
return body_;
}
const nsString&
body() const
{
return body_;
}
nsString&
tag()
{
return tag_;
}
const nsString&
tag() const
{
return tag_;
}
RefPtr<nsIURI>&
icon()
{
return icon_;
}
nsIURI*
icon() const
{
return icon_;
}
bool&
requireInteraction()
{
return requireInteraction_;
}
const bool&
requireInteraction() const
{
return requireInteraction_;
}
bool&
silent()
{
return silent_;
}
const bool&
silent() const
{
return silent_;
}
nsTArray<uint32_t>&
vibrate()
{
return vibrate_;
}
const nsTArray<uint32_t>&
vibrate() const
{
return vibrate_;
}
nsString&
dataSerialized()
{
return dataSerialized_;
}
const nsString&
dataSerialized() const
{
return dataSerialized_;
}
nsTArray<IPCNotificationAction>&
actions()
{
return actions_;
}
const nsTArray<IPCNotificationAction>&
actions() const
{
return actions_;
}
private:
::mozilla::ipc::IPDLStructMember<nsString> title_;
::mozilla::ipc::IPDLStructMember<NotificationDirection> dir_;
::mozilla::ipc::IPDLStructMember<nsString> lang_;
::mozilla::ipc::IPDLStructMember<nsString> body_;
::mozilla::ipc::IPDLStructMember<nsString> tag_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIURI>> icon_;
::mozilla::ipc::IPDLStructMember<bool> requireInteraction_;
::mozilla::ipc::IPDLStructMember<bool> silent_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<uint32_t>> vibrate_;
::mozilla::ipc::IPDLStructMember<nsString> dataSerialized_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<IPCNotificationAction>> actions_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCNotificationOptions>
{
typedef ::mozilla::dom::IPCNotificationOptions 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 IPCNotification|
//
namespace mozilla {
namespace dom {
class IPCNotification final
{
private:
typedef ::nsString nsString;
typedef ::mozilla::dom::IPCNotificationOptions IPCNotificationOptions;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
IPCNotification() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT IPCNotification(
const nsString& _id,
const IPCNotificationOptions& _options) :
id_(_id),
options_(_options)
{
}
MOZ_IMPLICIT IPCNotification(
nsString&& _id,
IPCNotificationOptions&& _options) :
id_(std::move(_id)),
options_(std::move(_options))
{
}
nsString&
id()
{
return id_;
}
const nsString&
id() const
{
return id_;
}
IPCNotificationOptions&
options()
{
return options_;
}
const IPCNotificationOptions&
options() const
{
return options_;
}
private:
::mozilla::ipc::IPDLStructMember<nsString> id_;
::mozilla::ipc::IPDLStructMember<IPCNotificationOptions> options_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCNotification>
{
typedef ::mozilla::dom::IPCNotification 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 IPCNotificationsOrError|
//
namespace mozilla {
namespace dom {
class IPCNotificationsOrError final
{
public:
enum Type {
T__None,
TArrayOfIPCNotification = 1,
Tnsresult,
T__Last = Tnsresult
};
private:
typedef ::mozilla::dom::IPCNotification IPCNotification;
typedef ::nsresult nsresult;
typedef nsTArray<IPCNotification> ArrayOfIPCNotification__tdef;
typedef nsresult nsresult__tdef;
nsTArray<IPCNotification>*
ptr_ArrayOfIPCNotification()
{
return (&(mVArrayOfIPCNotification));
}
const nsTArray<IPCNotification>*
constptr_ArrayOfIPCNotification() const
{
return (&(mVArrayOfIPCNotification));
}
nsresult*
ptr_nsresult()
{
return (&(mVnsresult));
}
const nsresult*
constptr_nsresult() const
{
return (&(mVnsresult));
}
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 IPCNotificationsOrError() :
mType(T__None)
{
}
MOZ_IMPLICIT IPCNotificationsOrError(const nsTArray<IPCNotification>& aOther);
MOZ_IMPLICIT IPCNotificationsOrError(nsTArray<IPCNotification>&& aOther);
MOZ_IMPLICIT IPCNotificationsOrError(const nsresult& aOther);
MOZ_IMPLICIT IPCNotificationsOrError(nsresult&& aOther);
MOZ_IMPLICIT IPCNotificationsOrError(const IPCNotificationsOrError& aOther);
MOZ_IMPLICIT IPCNotificationsOrError(IPCNotificationsOrError&& aOther);
~IPCNotificationsOrError();
Type
type() const
{
return mType;
}
IPCNotificationsOrError&
operator=(const nsTArray<IPCNotification>& aRhs);
IPCNotificationsOrError&
operator=(nsTArray<IPCNotification>&& aRhs);
IPCNotificationsOrError&
operator=(const nsresult& aRhs);
IPCNotificationsOrError&
operator=(nsresult&& aRhs);
IPCNotificationsOrError&
operator=(const IPCNotificationsOrError& aRhs);
IPCNotificationsOrError&
operator=(IPCNotificationsOrError&& aRhs);
nsTArray<IPCNotification>&
get_ArrayOfIPCNotification()
{
AssertSanity(TArrayOfIPCNotification);
return (*(ptr_ArrayOfIPCNotification()));
}
const nsTArray<IPCNotification>&
get_ArrayOfIPCNotification() const
{
AssertSanity(TArrayOfIPCNotification);
return (*(constptr_ArrayOfIPCNotification()));
}
operator nsTArray<IPCNotification>&()
{
return get_ArrayOfIPCNotification();
}
operator const nsTArray<IPCNotification>&() const
{
return get_ArrayOfIPCNotification();
}
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();
}
private:
union {
nsTArray<IPCNotification> mVArrayOfIPCNotification;
nsresult mVnsresult;
};
Type mType;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCNotificationsOrError>
{
typedef ::mozilla::dom::IPCNotificationsOrError paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
#endif // ifndef DOMTypes_h