#pragma once
#include "ArgumentCoder.h"
#include "Attachment.h"
#include "StringReference.h"
#include <wtf/EnumTraits.h>
#include <wtf/Vector.h>
#if HAVE(QOS_CLASSES)
#include <pthread/qos.h>
#endif
namespace IPC {
class DataReference;
class ImportanceAssertion;
class Decoder {
WTF_MAKE_FAST_ALLOCATED;
public:
Decoder(const uint8_t* buffer, size_t bufferSize, void (*bufferDeallocator)(const uint8_t*, size_t), Vector<Attachment>);
~Decoder();
Decoder(const Decoder&) = delete;
Decoder(Decoder&&) = delete;
StringReference messageReceiverName() const { return m_messageReceiverName; }
StringReference messageName() const { return m_messageName; }
uint64_t destinationID() const { return m_destinationID; }
bool isSyncMessage() const;
bool shouldDispatchMessageWhenWaitingForSyncReply() const;
bool shouldUseFullySynchronousModeForTesting() const;
#if PLATFORM(MAC)
void setImportanceAssertion(std::unique_ptr<ImportanceAssertion>);
#endif
#if HAVE(QOS_CLASSES)
void setQOSClassOverride(pthread_override_t override) { m_qosClassOverride = override; }
#endif
static std::unique_ptr<Decoder> unwrapForTesting(Decoder&);
size_t length() const { return m_bufferEnd - m_buffer; }
bool isInvalid() const { return m_bufferPos > m_bufferEnd; }
void markInvalid() { m_bufferPos = m_bufferEnd + 1; }
bool decodeFixedLengthData(uint8_t*, size_t, unsigned alignment);
bool decodeVariableLengthByteArray(DataReference&);
bool decode(bool&);
bool decode(uint8_t&);
bool decode(uint16_t&);
bool decode(uint32_t&);
bool decode(uint64_t&);
bool decode(int32_t&);
bool decode(int64_t&);
bool decode(float&);
bool decode(double&);
template<typename E>
auto decode(E& e) -> std::enable_if_t<std::is_enum<E>::value, bool>
{
uint64_t value;
if (!decode(value))
return false;
if (!isValidEnum<E>(value))
return false;
e = static_cast<E>(value);
return true;
}
template<typename T> bool decodeEnum(T& result)
{
static_assert(sizeof(T) <= 8, "Enum type T must not be larger than 64 bits!");
uint64_t value;
if (!decode(value))
return false;
result = static_cast<T>(value);
return true;
}
template<typename T>
bool bufferIsLargeEnoughToContain(size_t numElements) const
{
static_assert(std::is_arithmetic<T>::value, "Type T must have a fixed, known encoded size!");
if (numElements > std::numeric_limits<size_t>::max() / sizeof(T))
return false;
return bufferIsLargeEnoughToContain(alignof(T), numElements * sizeof(T));
}
template<typename T>
auto decode(T& t) -> std::enable_if_t<!std::is_enum<T>::value, bool>
{
return ArgumentCoder<T>::decode(*this, t);
}
bool removeAttachment(Attachment&);
static const bool isIPCDecoder = true;
private:
bool alignBufferPosition(unsigned alignment, size_t);
bool bufferIsLargeEnoughToContain(unsigned alignment, size_t) const;
const uint8_t* m_buffer;
const uint8_t* m_bufferPos;
const uint8_t* m_bufferEnd;
void (*m_bufferDeallocator)(const uint8_t*, size_t);
Vector<Attachment> m_attachments;
uint8_t m_messageFlags;
StringReference m_messageReceiverName;
StringReference m_messageName;
uint64_t m_destinationID;
#if PLATFORM(MAC)
std::unique_ptr<ImportanceAssertion> m_importanceAssertion;
#endif
#if HAVE(QOS_CLASSES)
pthread_override_t m_qosClassOverride { nullptr };
#endif
};
}