Copy as Markdown
Other Tools
//
// 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/SessionHistoryEntry.h"
#include "mozilla/gfx/Types.h"
#include "mozilla/ipc/BigBuffer.h"
#include "mozilla/ipc/IPCStreamUtils.h"
#include "mozilla/ipc/IPDLStructMember.h"
#include "mozilla/ipc/SerializedStructuredCloneBuffer.h"
#include "mozilla/net/ClassOfService.h"
#include "nsIContentSecurityPolicy.h"
#include "nsIPrincipal.h"
#include "nsIReferrerInfo.h"
#include "nsIURI.h"
#include "nsIVariant.h"
#include "nsIWidgetListener.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 ClonedMessageData|
//
namespace mozilla {
namespace dom {
class ClonedMessageData final
{
private:
typedef ::mozilla::SerializedStructuredCloneBuffer SerializedStructuredCloneBuffer;
typedef ::mozilla::dom::IPCBlob IPCBlob;
typedef ::mozilla::ipc::IPCStream IPCStream;
typedef ::mozilla::dom::MessagePortIdentifier MessagePortIdentifier;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ClonedMessageData() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ClonedMessageData(
SerializedStructuredCloneBuffer&& _data,
const nsTArray<IPCBlob>& _blobs,
const nsTArray<IPCStream>& _inputStreams,
const nsTArray<MessagePortIdentifier>& _identifiers) :
data_(std::move(_data)),
blobs_(_blobs),
inputStreams_(_inputStreams),
identifiers_(_identifiers)
{
}
MOZ_IMPLICIT ClonedMessageData(
SerializedStructuredCloneBuffer&& _data,
nsTArray<IPCBlob>&& _blobs,
nsTArray<IPCStream>&& _inputStreams,
nsTArray<MessagePortIdentifier>&& _identifiers) :
data_(std::move(_data)),
blobs_(std::move(_blobs)),
inputStreams_(std::move(_inputStreams)),
identifiers_(std::move(_identifiers))
{
}
SerializedStructuredCloneBuffer&
data()
{
return data_;
}
const SerializedStructuredCloneBuffer&
data() const
{
return data_;
}
nsTArray<IPCBlob>&
blobs()
{
return blobs_;
}
const nsTArray<IPCBlob>&
blobs() const
{
return blobs_;
}
nsTArray<IPCStream>&
inputStreams()
{
return inputStreams_;
}
const nsTArray<IPCStream>&
inputStreams() const
{
return inputStreams_;
}
nsTArray<MessagePortIdentifier>&
identifiers()
{
return identifiers_;
}
const nsTArray<MessagePortIdentifier>&
identifiers() const
{
return identifiers_;
}
private:
::mozilla::ipc::IPDLStructMember<SerializedStructuredCloneBuffer> data_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<IPCBlob>> blobs_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<IPCStream>> inputStreams_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<MessagePortIdentifier>> identifiers_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::ClonedMessageData>
{
typedef ::mozilla::dom::ClonedMessageData 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 ErrorMessageData|
//
namespace mozilla {
namespace dom {
class ErrorMessageData final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ErrorMessageData() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
private:
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::ErrorMessageData>
{
typedef ::mozilla::dom::ErrorMessageData 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 ClonedOrErrorMessageData|
//
namespace mozilla {
namespace dom {
class ClonedOrErrorMessageData final
{
public:
enum Type {
T__None,
TClonedMessageData = 1,
TErrorMessageData,
T__Last = TErrorMessageData
};
private:
typedef ::mozilla::dom::ClonedMessageData ClonedMessageData;
typedef ::mozilla::dom::ErrorMessageData ErrorMessageData;
typedef ClonedMessageData ClonedMessageData__tdef;
typedef ErrorMessageData ErrorMessageData__tdef;
union Value {
mozilla::AlignedStorage2<ClonedMessageData> VClonedMessageData;
mozilla::AlignedStorage2<ErrorMessageData> VErrorMessageData;
};
ClonedMessageData*
ptr_ClonedMessageData()
{
return ((mValue).VClonedMessageData).addr();
}
const ClonedMessageData*
constptr_ClonedMessageData() const
{
return ((mValue).VClonedMessageData).addr();
}
ErrorMessageData*
ptr_ErrorMessageData()
{
return ((mValue).VErrorMessageData).addr();
}
const ErrorMessageData*
constptr_ErrorMessageData() const
{
return ((mValue).VErrorMessageData).addr();
}
void
MaybeDestroy();
void
AssertSanity() const
{
MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
}
void
AssertSanity(Type aType) const
{
AssertSanity();
MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
}
public:
MOZ_IMPLICIT ClonedOrErrorMessageData() :
mType(T__None)
{
}
MOZ_IMPLICIT ClonedOrErrorMessageData(ClonedMessageData&& aOther);
MOZ_IMPLICIT ClonedOrErrorMessageData(const ErrorMessageData& aOther);
MOZ_IMPLICIT ClonedOrErrorMessageData(ErrorMessageData&& aOther);
MOZ_IMPLICIT ClonedOrErrorMessageData(ClonedOrErrorMessageData&& aOther);
~ClonedOrErrorMessageData();
Type
type() const
{
return mType;
}
ClonedOrErrorMessageData&
operator=(ClonedMessageData&& aRhs);
ClonedOrErrorMessageData&
operator=(const ErrorMessageData& aRhs);
ClonedOrErrorMessageData&
operator=(ErrorMessageData&& aRhs);
ClonedOrErrorMessageData&
operator=(ClonedOrErrorMessageData&& aRhs);
ClonedMessageData&
get_ClonedMessageData()
{
AssertSanity(TClonedMessageData);
return (*(ptr_ClonedMessageData()));
}
const ClonedMessageData&
get_ClonedMessageData() const
{
AssertSanity(TClonedMessageData);
return (*(constptr_ClonedMessageData()));
}
operator ClonedMessageData&()
{
return get_ClonedMessageData();
}
operator const ClonedMessageData&() const
{
return get_ClonedMessageData();
}
ErrorMessageData&
get_ErrorMessageData()
{
AssertSanity(TErrorMessageData);
return (*(ptr_ErrorMessageData()));
}
const ErrorMessageData&
get_ErrorMessageData() const
{
AssertSanity(TErrorMessageData);
return (*(constptr_ErrorMessageData()));
}
operator ErrorMessageData&()
{
return get_ErrorMessageData();
}
operator const ErrorMessageData&() const
{
return get_ErrorMessageData();
}
private:
Value mValue;
Type mType;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::ClonedOrErrorMessageData>
{
typedef ::mozilla::dom::ClonedOrErrorMessageData 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 RefMessageData|
//
namespace mozilla {
namespace dom {
class RefMessageData final
{
private:
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
RefMessageData() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT RefMessageData(const nsID& _uuid) :
uuid_(_uuid)
{
}
MOZ_IMPLICIT RefMessageData(nsID&& _uuid) :
uuid_(std::move(_uuid))
{
}
nsID&
uuid()
{
return uuid_;
}
const nsID&
uuid() const
{
return uuid_;
}
private:
::mozilla::ipc::IPDLStructMember<nsID> uuid_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::RefMessageData>
{
typedef ::mozilla::dom::RefMessageData 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 MessageDataType|
//
namespace mozilla {
namespace dom {
class MessageDataType final
{
public:
enum Type {
T__None,
TClonedMessageData = 1,
TRefMessageData,
T__Last = TRefMessageData
};
private:
typedef ::mozilla::dom::ClonedMessageData ClonedMessageData;
typedef ::mozilla::dom::RefMessageData RefMessageData;
typedef ClonedMessageData ClonedMessageData__tdef;
typedef RefMessageData RefMessageData__tdef;
union Value {
mozilla::AlignedStorage2<ClonedMessageData> VClonedMessageData;
mozilla::AlignedStorage2<RefMessageData> VRefMessageData;
};
ClonedMessageData*
ptr_ClonedMessageData()
{
return ((mValue).VClonedMessageData).addr();
}
const ClonedMessageData*
constptr_ClonedMessageData() const
{
return ((mValue).VClonedMessageData).addr();
}
RefMessageData*
ptr_RefMessageData()
{
return ((mValue).VRefMessageData).addr();
}
const RefMessageData*
constptr_RefMessageData() const
{
return ((mValue).VRefMessageData).addr();
}
void
MaybeDestroy();
void
AssertSanity() const
{
MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
}
void
AssertSanity(Type aType) const
{
AssertSanity();
MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
}
public:
MOZ_IMPLICIT MessageDataType() :
mType(T__None)
{
}
MOZ_IMPLICIT MessageDataType(ClonedMessageData&& aOther);
MOZ_IMPLICIT MessageDataType(const RefMessageData& aOther);
MOZ_IMPLICIT MessageDataType(RefMessageData&& aOther);
MOZ_IMPLICIT MessageDataType(MessageDataType&& aOther);
~MessageDataType();
Type
type() const
{
return mType;
}
MessageDataType&
operator=(ClonedMessageData&& aRhs);
MessageDataType&
operator=(const RefMessageData& aRhs);
MessageDataType&
operator=(RefMessageData&& aRhs);
MessageDataType&
operator=(MessageDataType&& aRhs);
ClonedMessageData&
get_ClonedMessageData()
{
AssertSanity(TClonedMessageData);
return (*(ptr_ClonedMessageData()));
}
const ClonedMessageData&
get_ClonedMessageData() const
{
AssertSanity(TClonedMessageData);
return (*(constptr_ClonedMessageData()));
}
operator ClonedMessageData&()
{
return get_ClonedMessageData();
}
operator const ClonedMessageData&() const
{
return get_ClonedMessageData();
}
RefMessageData&
get_RefMessageData()
{
AssertSanity(TRefMessageData);
return (*(ptr_RefMessageData()));
}
const RefMessageData&
get_RefMessageData() const
{
AssertSanity(TRefMessageData);
return (*(constptr_RefMessageData()));
}
operator RefMessageData&()
{
return get_RefMessageData();
}
operator const RefMessageData&() const
{
return get_RefMessageData();
}
private:
Value mValue;
Type mType;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::MessageDataType>
{
typedef ::mozilla::dom::MessageDataType 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 MessageData|
//
namespace mozilla {
namespace dom {
class MessageData final
{
private:
typedef ::nsID nsID;
typedef ::mozilla::dom::MessageDataType MessageDataType;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
MessageData() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT MessageData(
const mozilla::Maybe<nsID>& _agentClusterId,
MessageDataType&& _data) :
agentClusterId_(_agentClusterId),
data_(std::move(_data))
{
}
MOZ_IMPLICIT MessageData(
mozilla::Maybe<nsID>&& _agentClusterId,
MessageDataType&& _data) :
agentClusterId_(std::move(_agentClusterId)),
data_(std::move(_data))
{
}
mozilla::Maybe<nsID>&
agentClusterId()
{
return agentClusterId_;
}
const mozilla::Maybe<nsID>&
agentClusterId() const
{
return agentClusterId_;
}
MessageDataType&
data()
{
return data_;
}
const MessageDataType&
data() const
{
return data_;
}
private:
::mozilla::ipc::IPDLStructMember<mozilla::Maybe<nsID>> agentClusterId_;
::mozilla::ipc::IPDLStructMember<MessageDataType> data_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::MessageData>
{
typedef ::mozilla::dom::MessageData 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 FeaturePolicyInfo|
//
namespace mozilla {
namespace dom {
class FeaturePolicyInfo final
{
private:
typedef ::nsString nsString;
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
FeaturePolicyInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT FeaturePolicyInfo(
const nsTArray<nsString>& _inheritedDeniedFeatureNames,
const nsTArray<nsString>& _attributeEnabledFeatureNames,
const nsString& _declaredString,
nsIPrincipal* _defaultOrigin,
nsIPrincipal* _selfOrigin,
nsIPrincipal* _srcOrigin) :
inheritedDeniedFeatureNames_(_inheritedDeniedFeatureNames),
attributeEnabledFeatureNames_(_attributeEnabledFeatureNames),
declaredString_(_declaredString),
defaultOrigin_(_defaultOrigin),
selfOrigin_(_selfOrigin),
srcOrigin_(_srcOrigin)
{
}
MOZ_IMPLICIT FeaturePolicyInfo(
nsTArray<nsString>&& _inheritedDeniedFeatureNames,
nsTArray<nsString>&& _attributeEnabledFeatureNames,
nsString&& _declaredString,
RefPtr<nsIPrincipal>&& _defaultOrigin,
RefPtr<nsIPrincipal>&& _selfOrigin,
RefPtr<nsIPrincipal>&& _srcOrigin) :
inheritedDeniedFeatureNames_(std::move(_inheritedDeniedFeatureNames)),
attributeEnabledFeatureNames_(std::move(_attributeEnabledFeatureNames)),
declaredString_(std::move(_declaredString)),
defaultOrigin_(std::move(_defaultOrigin)),
selfOrigin_(std::move(_selfOrigin)),
srcOrigin_(std::move(_srcOrigin))
{
}
nsTArray<nsString>&
inheritedDeniedFeatureNames()
{
return inheritedDeniedFeatureNames_;
}
const nsTArray<nsString>&
inheritedDeniedFeatureNames() const
{
return inheritedDeniedFeatureNames_;
}
nsTArray<nsString>&
attributeEnabledFeatureNames()
{
return attributeEnabledFeatureNames_;
}
const nsTArray<nsString>&
attributeEnabledFeatureNames() const
{
return attributeEnabledFeatureNames_;
}
nsString&
declaredString()
{
return declaredString_;
}
const nsString&
declaredString() const
{
return declaredString_;
}
RefPtr<nsIPrincipal>&
defaultOrigin()
{
return defaultOrigin_;
}
nsIPrincipal*
defaultOrigin() const
{
return defaultOrigin_;
}
RefPtr<nsIPrincipal>&
selfOrigin()
{
return selfOrigin_;
}
nsIPrincipal*
selfOrigin() const
{
return selfOrigin_;
}
RefPtr<nsIPrincipal>&
srcOrigin()
{
return srcOrigin_;
}
nsIPrincipal*
srcOrigin() const
{
return srcOrigin_;
}
private:
::mozilla::ipc::IPDLStructMember<CopyableTArray<nsString>> inheritedDeniedFeatureNames_;
::mozilla::ipc::IPDLStructMember<CopyableTArray<nsString>> attributeEnabledFeatureNames_;
::mozilla::ipc::IPDLStructMember<nsString> declaredString_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIPrincipal>> defaultOrigin_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIPrincipal>> selfOrigin_;
::mozilla::ipc::IPDLStructMember<RefPtr<nsIPrincipal>> srcOrigin_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::FeaturePolicyInfo>
{
typedef ::mozilla::dom::FeaturePolicyInfo 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 ::nsIContentSecurityPolicy nsIContentSecurityPolicy;
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 ::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
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,
nsIContentSecurityPolicy* _Csp,
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 uint32_t& _TriggeringSandboxFlags,
const uint64_t& _TriggeringWindowId,
const bool& _TriggeringStorageAccess,
const mozilla::Maybe<int32_t>& _CancelContentJSEpoch,
const bool& _ResultPrincipalURIIsSome,
const bool& _KeepResultPrincipalURIIfSet,
const bool& _LoadReplace,
const bool& _InheritPrincipal,
const bool& _PrincipalIsExplicit,
const bool& _ForceAllowDataURI,
const bool& _IsExemptFromHTTPSFirstMode,
const bool& _OriginalFrameSrc,
const bool& _IsFormSubmission,
const bool& _FirstParty,
const bool& _HasValidUserGestureActivation,
const bool& _AllowFocusMove,
const bool& _IsFromProcessingFrameAttributes,
const bool& _WasSchemelessInput,
const bool& _ChannelInitialized,
const bool& _TryToReplaceWithSessionHistoryLoad,
const bool& _IsMetaRefresh) :
URI_(_URI),
OriginalURI_(_OriginalURI),
ResultPrincipalURI_(_ResultPrincipalURI),
TriggeringPrincipal_(_TriggeringPrincipal),
ReferrerInfo_(_ReferrerInfo),
PrincipalToInherit_(_PrincipalToInherit),
PartitionedPrincipalToInherit_(_PartitionedPrincipalToInherit),
BaseURI_(_BaseURI),
Csp_(_Csp),
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),
TriggeringStorageAccess_(_TriggeringStorageAccess),
CancelContentJSEpoch_(_CancelContentJSEpoch),
ResultPrincipalURIIsSome_(_ResultPrincipalURIIsSome),
KeepResultPrincipalURIIfSet_(_KeepResultPrincipalURIIfSet),
LoadReplace_(_LoadReplace),
InheritPrincipal_(_InheritPrincipal),
PrincipalIsExplicit_(_PrincipalIsExplicit),
ForceAllowDataURI_(_ForceAllowDataURI),
IsExemptFromHTTPSFirstMode_(_IsExemptFromHTTPSFirstMode),
OriginalFrameSrc_(_OriginalFrameSrc),
IsFormSubmission_(_IsFormSubmission),
FirstParty_(_FirstParty),
HasValidUserGestureActivation_(_HasValidUserGestureActivation),
AllowFocusMove_(_AllowFocusMove),
IsFromProcessingFrameAttributes_(_IsFromProcessingFrameAttributes),
WasSchemelessInput_(_WasSchemelessInput),
ChannelInitialized_(_ChannelInitialized),
TryToReplaceWithSessionHistoryLoad_(_TryToReplaceWithSessionHistoryLoad),
IsMetaRefresh_(_IsMetaRefresh),
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<nsIContentSecurityPolicy>&& _Csp,
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,
uint32_t&& _TriggeringSandboxFlags,
uint64_t&& _TriggeringWindowId,
bool&& _TriggeringStorageAccess,
mozilla::Maybe<int32_t>&& _CancelContentJSEpoch,
bool&& _ResultPrincipalURIIsSome,
bool&& _KeepResultPrincipalURIIfSet,
bool&& _LoadReplace,
bool&& _InheritPrincipal,
bool&& _PrincipalIsExplicit,
bool&& _ForceAllowDataURI,
bool&& _IsExemptFromHTTPSFirstMode,
bool&& _OriginalFrameSrc,
bool&& _IsFormSubmission,
bool&& _FirstParty,
bool&& _HasValidUserGestureActivation,
bool&& _AllowFocusMove,
bool&& _IsFromProcessingFrameAttributes,
bool&& _WasSchemelessInput,
bool&& _ChannelInitialized,
bool&& _TryToReplaceWithSessionHistoryLoad,
bool&& _IsMetaRefresh) :
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)),
Csp_(std::move(_Csp)),
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)),
TriggeringStorageAccess_(std::move(_TriggeringStorageAccess)),
CancelContentJSEpoch_(std::move(_CancelContentJSEpoch)),
ResultPrincipalURIIsSome_(std::move(_ResultPrincipalURIIsSome)),
KeepResultPrincipalURIIfSet_(std::move(_KeepResultPrincipalURIIfSet)),
LoadReplace_(std::move(_LoadReplace)),
InheritPrincipal_(std::move(_InheritPrincipal)),
PrincipalIsExplicit_(std::move(_PrincipalIsExplicit)),
ForceAllowDataURI_(std::move(_ForceAllowDataURI)),
IsExemptFromHTTPSFirstMode_(std::move(_IsExemptFromHTTPSFirstMode)),
OriginalFrameSrc_(std::move(_OriginalFrameSrc)),
IsFormSubmission_(std::move(_IsFormSubmission)),
FirstParty_(std::move(_FirstParty)),
HasValidUserGestureActivation_(std::move(_HasValidUserGestureActivation)),
AllowFocusMove_(std::move(_AllowFocusMove)),
IsFromProcessingFrameAttributes_(std::move(_IsFromProcessingFrameAttributes)),
WasSchemelessInput_(std::move(_WasSchemelessInput)),
ChannelInitialized_(std::move(_ChannelInitialized)),
TryToReplaceWithSessionHistoryLoad_(std::move(_TryToReplaceWithSessionHistoryLoad)),
IsMetaRefresh_(std::move(_IsMetaRefresh)),
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<nsIContentSecurityPolicy>&
Csp()
{
return Csp_;
}
nsIContentSecurityPolicy*
Csp() const
{
return Csp_;
}
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_;
}
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_;
}
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&
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&
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&
AllowFocusMove()
{
return AllowFocusMove_;
}
const bool&
AllowFocusMove() const
{
return AllowFocusMove_;
}
bool&
IsFromProcessingFrameAttributes()
{
return IsFromProcessingFrameAttributes_;
}
const bool&
IsFromProcessingFrameAttributes() const
{
return IsFromProcessingFrameAttributes_;
}
bool&
WasSchemelessInput()
{
return WasSchemelessInput_;
}
const bool&
WasSchemelessInput() const
{
return WasSchemelessInput_;
}
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_;
}
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<nsIContentSecurityPolicy>> Csp_;
::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<bool> TriggeringStorageAccess_;
::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> ForceAllowDataURI_;
::mozilla::ipc::IPDLStructMember<bool> IsExemptFromHTTPSFirstMode_;
::mozilla::ipc::IPDLStructMember<bool> OriginalFrameSrc_;
::mozilla::ipc::IPDLStructMember<bool> IsFormSubmission_;
::mozilla::ipc::IPDLStructMember<bool> FirstParty_;
::mozilla::ipc::IPDLStructMember<bool> HasValidUserGestureActivation_;
::mozilla::ipc::IPDLStructMember<bool> AllowFocusMove_;
::mozilla::ipc::IPDLStructMember<bool> IsFromProcessingFrameAttributes_;
::mozilla::ipc::IPDLStructMember<bool> WasSchemelessInput_;
::mozilla::ipc::IPDLStructMember<bool> ChannelInitialized_;
::mozilla::ipc::IPDLStructMember<bool> TryToReplaceWithSessionHistoryLoad_;
::mozilla::ipc::IPDLStructMember<bool> IsMetaRefresh_;
::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 bool& _timingEnabled,
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 TimeStamp& _launchServiceWorkerStart,
const TimeStamp& _launchServiceWorkerEnd,
const TimeStamp& _dispatchFetchEventStart,
const TimeStamp& _dispatchFetchEventEnd,
const TimeStamp& _handleFetchEventStart,
const TimeStamp& _handleFetchEventEnd,
const TimeStamp& _responseStart,
const TimeStamp& _responseEnd) :
timingEnabled_(_timingEnabled),
asyncOpen_(_asyncOpen),
channelCreation_(_channelCreation),
redirectStart_(_redirectStart),
redirectEnd_(_redirectEnd),
initiatorType_(_initiatorType),
allRedirectsSameOrigin_(_allRedirectsSameOrigin),
allRedirectsPassTimingAllowCheck_(_allRedirectsPassTimingAllowCheck),
timingAllowCheckForPrincipal_(_timingAllowCheckForPrincipal),
launchServiceWorkerStart_(_launchServiceWorkerStart),
launchServiceWorkerEnd_(_launchServiceWorkerEnd),
dispatchFetchEventStart_(_dispatchFetchEventStart),
dispatchFetchEventEnd_(_dispatchFetchEventEnd),
handleFetchEventStart_(_handleFetchEventStart),
handleFetchEventEnd_(_handleFetchEventEnd),
responseStart_(_responseStart),
responseEnd_(_responseEnd),
redirectCount_(_redirectCount),
internalRedirectCount_(_internalRedirectCount)
{
}
MOZ_IMPLICIT TimedChannelInfo(
bool&& _timingEnabled,
int8_t&& _redirectCount,
int8_t&& _internalRedirectCount,
TimeStamp&& _asyncOpen,
TimeStamp&& _channelCreation,
TimeStamp&& _redirectStart,
TimeStamp&& _redirectEnd,
nsString&& _initiatorType,
bool&& _allRedirectsSameOrigin,
bool&& _allRedirectsPassTimingAllowCheck,
mozilla::Maybe<bool>&& _timingAllowCheckForPrincipal,
TimeStamp&& _launchServiceWorkerStart,
TimeStamp&& _launchServiceWorkerEnd,
TimeStamp&& _dispatchFetchEventStart,
TimeStamp&& _dispatchFetchEventEnd,
TimeStamp&& _handleFetchEventStart,
TimeStamp&& _handleFetchEventEnd,
TimeStamp&& _responseStart,
TimeStamp&& _responseEnd) :
timingEnabled_(std::move(_timingEnabled)),
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)),
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))
{
}
bool&
timingEnabled()
{
return timingEnabled_;
}
const bool&
timingEnabled() const
{
return timingEnabled_;
}
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_;
}
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<bool> timingEnabled_;
::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<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;
union Value {
mozilla::AlignedStorage2<bool> Vbool;
mozilla::AlignedStorage2<uint8_t> Vuint8_t;
mozilla::AlignedStorage2<int16_t> Vint16_t;
mozilla::AlignedStorage2<uint16_t> Vuint16_t;
mozilla::AlignedStorage2<int32_t> Vint32_t;
mozilla::AlignedStorage2<uint32_t> Vuint32_t;
mozilla::AlignedStorage2<float> Vfloat;
mozilla::AlignedStorage2<double> Vdouble;
mozilla::AlignedStorage2<nsID> VnsID;
mozilla::AlignedStorage2<nsString> VnsString;
mozilla::AlignedStorage2<nsCString> VnsCString;
mozilla::AlignedStorage2<RefPtr<nsIURI>> VnsIURI;
mozilla::AlignedStorage2<RefPtr<nsIPrincipal>> VnsIPrincipal;
};
bool*
ptr_bool()
{
return ((mValue).Vbool).addr();
}
const bool*
constptr_bool() const
{
return ((mValue).Vbool).addr();
}
uint8_t*
ptr_uint8_t()
{
return ((mValue).Vuint8_t).addr();
}
const uint8_t*
constptr_uint8_t() const
{
return ((mValue).Vuint8_t).addr();
}
int16_t*
ptr_int16_t()
{
return ((mValue).Vint16_t).addr();
}
const int16_t*
constptr_int16_t() const
{
return ((mValue).Vint16_t).addr();
}
uint16_t*
ptr_uint16_t()
{
return ((mValue).Vuint16_t).addr();
}
const uint16_t*
constptr_uint16_t() const
{
return ((mValue).Vuint16_t).addr();
}
int32_t*
ptr_int32_t()
{
return ((mValue).Vint32_t).addr();
}
const int32_t*
constptr_int32_t() const
{
return ((mValue).Vint32_t).addr();
}
uint32_t*
ptr_uint32_t()
{
return ((mValue).Vuint32_t).addr();
}
const uint32_t*
constptr_uint32_t() const
{
return ((mValue).Vuint32_t).addr();
}
float*
ptr_float()
{
return ((mValue).Vfloat).addr();
}
const float*
constptr_float() const
{
return ((mValue).Vfloat).addr();
}
double*
ptr_double()
{
return ((mValue).Vdouble).addr();
}
const double*
constptr_double() const
{
return ((mValue).Vdouble).addr();
}
nsID*
ptr_nsID()
{
return ((mValue).VnsID).addr();
}
const nsID*
constptr_nsID() const
{
return ((mValue).VnsID).addr();
}
nsString*
ptr_nsString()
{
return ((mValue).VnsString).addr();
}
const nsString*
constptr_nsString() const
{
return ((mValue).VnsString).addr();
}
nsCString*
ptr_nsCString()
{
return ((mValue).VnsCString).addr();
}
const nsCString*
constptr_nsCString() const
{
return ((mValue).VnsCString).addr();
}
RefPtr<nsIURI>*
ptr_nsIURI()
{
return ((mValue).VnsIURI).addr();
}
const RefPtr<nsIURI>*
constptr_nsIURI() const
{
return ((mValue).VnsIURI).addr();
}
RefPtr<nsIPrincipal>*
ptr_nsIPrincipal()
{
return ((mValue).VnsIPrincipal).addr();
}
const RefPtr<nsIPrincipal>*
constptr_nsIPrincipal() const
{
return ((mValue).VnsIPrincipal).addr();
}
void
MaybeDestroy();
void
AssertSanity() const
{
MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
}
void
AssertSanity(Type aType) const
{
AssertSanity();
MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
}
public:
MOZ_IMPLICIT 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:
Value mValue;
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) :
name_(_name),
fakeShowInfo_(_fakeShowInfo),
isTransparent_(_isTransparent),
defaultScale_(_defaultScale),
dpi_(_dpi),
widgetRounding_(_widgetRounding)
{
}
MOZ_IMPLICIT ParentShowInfo(
nsString&& _name,
bool&& _fakeShowInfo,
bool&& _isTransparent,
float&& _dpi,
int32_t&& _widgetRounding,
double&& _defaultScale) :
name_(std::move(_name)),
fakeShowInfo_(std::move(_fakeShowInfo)),
isTransparent_(std::move(_isTransparent)),
defaultScale_(std::move(_defaultScale)),
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_;
}
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<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::ScreenIntSize ScreenIntSize;
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 ScreenIntSize& _size,
const ScrollbarPreference& _scrollbarPreference,
const nsSizeMode& _sizeMode) :
size_(_size),
scrollbarPreference_(_scrollbarPreference),
sizeMode_(_sizeMode)
{
}
MOZ_IMPLICIT OwnerShowInfo(
ScreenIntSize&& _size,
ScrollbarPreference&& _scrollbarPreference,
nsSizeMode&& _sizeMode) :
size_(std::move(_size)),
scrollbarPreference_(std::move(_scrollbarPreference)),
sizeMode_(std::move(_sizeMode))
{
}
ScreenIntSize&
size()
{
return size_;
}
const ScreenIntSize&
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<ScreenIntSize> 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
#endif // ifndef DOMTypes_h