Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#ifndef PerformanceTimingTypes_h
#define PerformanceTimingTypes_h
#include "mozilla/Attributes.h"
#include "IPCMessageStart.h"
#include "mozilla/RefPtr.h"
#include "nsString.h"
#include "nsTArray.h"
#include "nsTHashtable.h"
#include "mozilla/MozPromise.h"
#include "mozilla/OperatorNewExtensions.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/ipc/ByteBuf.h"
#include "mozilla/ipc/FileDescriptor.h"
#include "mozilla/ipc/IPCForwards.h"
#include "mozilla/ipc/Shmem.h"
// Headers for typedefs
#include "mozilla/TimeStamp.h"
#include "mozilla/ipc/IPDLStructMember.h"
#include "nsDOMNavigationTiming.h"
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct IPCServerTiming|
//
namespace mozilla {
namespace dom {
class IPCServerTiming final
{
private:
typedef ::nsCString nsCString;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
IPCServerTiming() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT IPCServerTiming(
const nsCString& _name,
const double& _duration,
const nsCString& _description) :
name_(_name),
description_(_description),
duration_(_duration)
{
}
MOZ_IMPLICIT IPCServerTiming(
nsCString&& _name,
double&& _duration,
nsCString&& _description) :
name_(std::move(_name)),
description_(std::move(_description)),
duration_(std::move(_duration))
{
}
nsCString&
name()
{
return name_;
}
const nsCString&
name() const
{
return name_;
}
double&
duration()
{
return duration_;
}
const double&
duration() const
{
return duration_;
}
nsCString&
description()
{
return description_;
}
const nsCString&
description() const
{
return description_;
}
private:
::mozilla::ipc::IPDLStructMember<nsCString> name_;
::mozilla::ipc::IPDLStructMember<nsCString> description_;
::mozilla::ipc::IPDLStructMember<double> duration_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCServerTiming>
{
typedef ::mozilla::dom::IPCServerTiming 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 IPCPerformanceTimingData|
//
namespace mozilla {
namespace dom {
class IPCPerformanceTimingData final
{
private:
typedef ::mozilla::dom::IPCServerTiming IPCServerTiming;
typedef ::nsString nsString;
typedef ::mozilla::TimeStamp TimeStamp;
typedef ::DOMHighResTimeStamp DOMHighResTimeStamp;
typedef ::uint64_t uint64_t;
typedef ::uint8_t uint8_t;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
IPCPerformanceTimingData() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT IPCPerformanceTimingData(
const nsTArray<IPCServerTiming>& _serverTiming,
const nsString& _nextHopProtocol,
const TimeStamp& _asyncOpen,
const TimeStamp& _redirectStart,
const TimeStamp& _redirectEnd,
const TimeStamp& _domainLookupStart,
const TimeStamp& _domainLookupEnd,
const TimeStamp& _connectStart,
const TimeStamp& _secureConnectionStart,
const TimeStamp& _connectEnd,
const TimeStamp& _requestStart,
const TimeStamp& _responseStart,
const TimeStamp& _cacheReadStart,
const TimeStamp& _responseEnd,
const TimeStamp& _cacheReadEnd,
const TimeStamp& _workerStart,
const TimeStamp& _workerRequestStart,
const TimeStamp& _workerResponseEnd,
const DOMHighResTimeStamp& _zeroTime,
const DOMHighResTimeStamp& _fetchStart,
const uint64_t& _encodedBodySize,
const uint64_t& _transferSize,
const uint64_t& _decodedBodySize,
const uint8_t& _redirectCount,
const bool& _allRedirectsSameOrigin,
const bool& _allRedirectsPassTAO,
const bool& _secureConnection,
const bool& _timingAllowed,
const bool& _initialized) :
serverTiming_(_serverTiming),
nextHopProtocol_(_nextHopProtocol),
asyncOpen_(_asyncOpen),
redirectStart_(_redirectStart),
redirectEnd_(_redirectEnd),
domainLookupStart_(_domainLookupStart),
domainLookupEnd_(_domainLookupEnd),
connectStart_(_connectStart),
secureConnectionStart_(_secureConnectionStart),
connectEnd_(_connectEnd),
requestStart_(_requestStart),
responseStart_(_responseStart),
cacheReadStart_(_cacheReadStart),
responseEnd_(_responseEnd),
cacheReadEnd_(_cacheReadEnd),
workerStart_(_workerStart),
workerRequestStart_(_workerRequestStart),
workerResponseEnd_(_workerResponseEnd),
zeroTime_(_zeroTime),
fetchStart_(_fetchStart),
allRedirectsSameOrigin_(_allRedirectsSameOrigin),
allRedirectsPassTAO_(_allRedirectsPassTAO),
secureConnection_(_secureConnection),
timingAllowed_(_timingAllowed),
initialized_(_initialized),
encodedBodySize_(_encodedBodySize),
transferSize_(_transferSize),
decodedBodySize_(_decodedBodySize),
redirectCount_(_redirectCount)
{
}
MOZ_IMPLICIT IPCPerformanceTimingData(
nsTArray<IPCServerTiming>&& _serverTiming,
nsString&& _nextHopProtocol,
TimeStamp&& _asyncOpen,
TimeStamp&& _redirectStart,
TimeStamp&& _redirectEnd,
TimeStamp&& _domainLookupStart,
TimeStamp&& _domainLookupEnd,
TimeStamp&& _connectStart,
TimeStamp&& _secureConnectionStart,
TimeStamp&& _connectEnd,
TimeStamp&& _requestStart,
TimeStamp&& _responseStart,
TimeStamp&& _cacheReadStart,
TimeStamp&& _responseEnd,
TimeStamp&& _cacheReadEnd,
TimeStamp&& _workerStart,
TimeStamp&& _workerRequestStart,
TimeStamp&& _workerResponseEnd,
DOMHighResTimeStamp&& _zeroTime,
DOMHighResTimeStamp&& _fetchStart,
uint64_t&& _encodedBodySize,
uint64_t&& _transferSize,
uint64_t&& _decodedBodySize,
uint8_t&& _redirectCount,
bool&& _allRedirectsSameOrigin,
bool&& _allRedirectsPassTAO,
bool&& _secureConnection,
bool&& _timingAllowed,
bool&& _initialized) :
serverTiming_(std::move(_serverTiming)),
nextHopProtocol_(std::move(_nextHopProtocol)),
asyncOpen_(std::move(_asyncOpen)),
redirectStart_(std::move(_redirectStart)),
redirectEnd_(std::move(_redirectEnd)),
domainLookupStart_(std::move(_domainLookupStart)),
domainLookupEnd_(std::move(_domainLookupEnd)),
connectStart_(std::move(_connectStart)),
secureConnectionStart_(std::move(_secureConnectionStart)),
connectEnd_(std::move(_connectEnd)),
requestStart_(std::move(_requestStart)),
responseStart_(std::move(_responseStart)),
cacheReadStart_(std::move(_cacheReadStart)),
responseEnd_(std::move(_responseEnd)),
cacheReadEnd_(std::move(_cacheReadEnd)),
workerStart_(std::move(_workerStart)),
workerRequestStart_(std::move(_workerRequestStart)),
workerResponseEnd_(std::move(_workerResponseEnd)),
zeroTime_(std::move(_zeroTime)),
fetchStart_(std::move(_fetchStart)),
allRedirectsSameOrigin_(std::move(_allRedirectsSameOrigin)),
allRedirectsPassTAO_(std::move(_allRedirectsPassTAO)),
secureConnection_(std::move(_secureConnection)),
timingAllowed_(std::move(_timingAllowed)),
initialized_(std::move(_initialized)),
encodedBodySize_(std::move(_encodedBodySize)),
transferSize_(std::move(_transferSize)),
decodedBodySize_(std::move(_decodedBodySize)),
redirectCount_(std::move(_redirectCount))
{
}
nsTArray<IPCServerTiming>&
serverTiming()
{
return serverTiming_;
}
const nsTArray<IPCServerTiming>&
serverTiming() const
{
return serverTiming_;
}
nsString&
nextHopProtocol()
{
return nextHopProtocol_;
}
const nsString&
nextHopProtocol() const
{
return nextHopProtocol_;
}
TimeStamp&
asyncOpen()
{
return asyncOpen_;
}
const TimeStamp&
asyncOpen() const
{
return asyncOpen_;
}
TimeStamp&
redirectStart()
{
return redirectStart_;
}
const TimeStamp&
redirectStart() const
{
return redirectStart_;
}
TimeStamp&
redirectEnd()
{
return redirectEnd_;
}
const TimeStamp&
redirectEnd() const
{
return redirectEnd_;
}
TimeStamp&
domainLookupStart()
{
return domainLookupStart_;
}
const TimeStamp&
domainLookupStart() const
{
return domainLookupStart_;
}
TimeStamp&
domainLookupEnd()
{
return domainLookupEnd_;
}
const TimeStamp&
domainLookupEnd() const
{
return domainLookupEnd_;
}
TimeStamp&
connectStart()
{
return connectStart_;
}
const TimeStamp&
connectStart() const
{
return connectStart_;
}
TimeStamp&
secureConnectionStart()
{
return secureConnectionStart_;
}
const TimeStamp&
secureConnectionStart() const
{
return secureConnectionStart_;
}
TimeStamp&
connectEnd()
{
return connectEnd_;
}
const TimeStamp&
connectEnd() const
{
return connectEnd_;
}
TimeStamp&
requestStart()
{
return requestStart_;
}
const TimeStamp&
requestStart() const
{
return requestStart_;
}
TimeStamp&
responseStart()
{
return responseStart_;
}
const TimeStamp&
responseStart() const
{
return responseStart_;
}
TimeStamp&
cacheReadStart()
{
return cacheReadStart_;
}
const TimeStamp&
cacheReadStart() const
{
return cacheReadStart_;
}
TimeStamp&
responseEnd()
{
return responseEnd_;
}
const TimeStamp&
responseEnd() const
{
return responseEnd_;
}
TimeStamp&
cacheReadEnd()
{
return cacheReadEnd_;
}
const TimeStamp&
cacheReadEnd() const
{
return cacheReadEnd_;
}
TimeStamp&
workerStart()
{
return workerStart_;
}
const TimeStamp&
workerStart() const
{
return workerStart_;
}
TimeStamp&
workerRequestStart()
{
return workerRequestStart_;
}
const TimeStamp&
workerRequestStart() const
{
return workerRequestStart_;
}
TimeStamp&
workerResponseEnd()
{
return workerResponseEnd_;
}
const TimeStamp&
workerResponseEnd() const
{
return workerResponseEnd_;
}
DOMHighResTimeStamp&
zeroTime()
{
return zeroTime_;
}
const DOMHighResTimeStamp&
zeroTime() const
{
return zeroTime_;
}
DOMHighResTimeStamp&
fetchStart()
{
return fetchStart_;
}
const DOMHighResTimeStamp&
fetchStart() const
{
return fetchStart_;
}
uint64_t&
encodedBodySize()
{
return encodedBodySize_;
}
const uint64_t&
encodedBodySize() const
{
return encodedBodySize_;
}
uint64_t&
transferSize()
{
return transferSize_;
}
const uint64_t&
transferSize() const
{
return transferSize_;
}
uint64_t&
decodedBodySize()
{
return decodedBodySize_;
}
const uint64_t&
decodedBodySize() const
{
return decodedBodySize_;
}
uint8_t&
redirectCount()
{
return redirectCount_;
}
const uint8_t&
redirectCount() const
{
return redirectCount_;
}
bool&
allRedirectsSameOrigin()
{
return allRedirectsSameOrigin_;
}
const bool&
allRedirectsSameOrigin() const
{
return allRedirectsSameOrigin_;
}
bool&
allRedirectsPassTAO()
{
return allRedirectsPassTAO_;
}
const bool&
allRedirectsPassTAO() const
{
return allRedirectsPassTAO_;
}
bool&
secureConnection()
{
return secureConnection_;
}
const bool&
secureConnection() const
{
return secureConnection_;
}
bool&
timingAllowed()
{
return timingAllowed_;
}
const bool&
timingAllowed() const
{
return timingAllowed_;
}
bool&
initialized()
{
return initialized_;
}
const bool&
initialized() const
{
return initialized_;
}
private:
void
StaticAssertions() const;
::mozilla::ipc::IPDLStructMember<CopyableTArray<IPCServerTiming>> serverTiming_;
::mozilla::ipc::IPDLStructMember<nsString> nextHopProtocol_;
::mozilla::ipc::IPDLStructMember<TimeStamp> asyncOpen_;
::mozilla::ipc::IPDLStructMember<TimeStamp> redirectStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> redirectEnd_;
::mozilla::ipc::IPDLStructMember<TimeStamp> domainLookupStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> domainLookupEnd_;
::mozilla::ipc::IPDLStructMember<TimeStamp> connectStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> secureConnectionStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> connectEnd_;
::mozilla::ipc::IPDLStructMember<TimeStamp> requestStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> responseStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> cacheReadStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> responseEnd_;
::mozilla::ipc::IPDLStructMember<TimeStamp> cacheReadEnd_;
::mozilla::ipc::IPDLStructMember<TimeStamp> workerStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> workerRequestStart_;
::mozilla::ipc::IPDLStructMember<TimeStamp> workerResponseEnd_;
::mozilla::ipc::IPDLStructMember<DOMHighResTimeStamp> zeroTime_;
::mozilla::ipc::IPDLStructMember<DOMHighResTimeStamp> fetchStart_;
::mozilla::ipc::IPDLStructMember<bool> allRedirectsSameOrigin_;
::mozilla::ipc::IPDLStructMember<bool> allRedirectsPassTAO_;
::mozilla::ipc::IPDLStructMember<bool> secureConnection_;
::mozilla::ipc::IPDLStructMember<bool> timingAllowed_;
::mozilla::ipc::IPDLStructMember<bool> initialized_;
::mozilla::ipc::IPDLStructMember<uint64_t> encodedBodySize_;
::mozilla::ipc::IPDLStructMember<uint64_t> transferSize_;
::mozilla::ipc::IPDLStructMember<uint64_t> decodedBodySize_;
::mozilla::ipc::IPDLStructMember<uint8_t> redirectCount_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCPerformanceTimingData>
{
typedef ::mozilla::dom::IPCPerformanceTimingData paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
#endif // ifndef PerformanceTimingTypes_h