2021-09-11 02:11:11 +00:00
|
|
|
|
2020-01-08 22:19:14 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
|
2020-04-30 22:21:45 +00:00
|
|
|
#ifndef WEBGLQUEUEPARAMTRAITS_H_
|
|
|
|
#define WEBGLQUEUEPARAMTRAITS_H_
|
2020-01-08 22:19:14 +00:00
|
|
|
|
2020-03-28 13:57:18 +00:00
|
|
|
#include <type_traits>
|
|
|
|
|
2020-12-10 11:09:21 +00:00
|
|
|
#include "ipc/EnumSerializer.h"
|
2020-01-08 22:19:14 +00:00
|
|
|
#include "TexUnpackBlob.h"
|
|
|
|
#include "WebGLTypes.h"
|
|
|
|
|
Bug 1778808 - Use stricter TiedFields instead of IsTriviallySerializable in WebGL's QueueParamTraits. r=lsalzman,nika
```
// We guarantee our robustness via these requirements:
// * Object.MutTiedFields() gives us a tuple,
// * where the combined sizeofs all field types sums to sizeof(Object),
// * (thus we know we are exhaustively listing all fields)
// * where feeding each field back into ParamTraits succeeds,
// * and ParamTraits is only automated for BytesAlwaysValidT<T> types.
// (BytesAlwaysValidT rejects bool and enum types, and only accepts int/float
// types, or array or std::arrays of such types)
// (Yes, bit-field fields are rejected by MutTiedFields too)
```
BytesAlwaysValidT<T> is the same as the IsTriviallySerializable<T> that
it replaces, however the emphasis is different, and should discourage
tagging structs as IsTriviallySerializable, since they more clearly
aren't BytesAlwaysValid.
Differential Revision: https://phabricator.services.mozilla.com/D151676
2022-08-09 21:01:55 +00:00
|
|
|
namespace mozilla {
|
|
|
|
namespace webgl {
|
2020-01-08 22:19:14 +00:00
|
|
|
template <typename T>
|
2020-04-30 22:21:45 +00:00
|
|
|
struct QueueParamTraits;
|
2020-01-08 22:19:14 +00:00
|
|
|
|
Bug 1778808 - Use stricter TiedFields instead of IsTriviallySerializable in WebGL's QueueParamTraits. r=lsalzman,nika
```
// We guarantee our robustness via these requirements:
// * Object.MutTiedFields() gives us a tuple,
// * where the combined sizeofs all field types sums to sizeof(Object),
// * (thus we know we are exhaustively listing all fields)
// * where feeding each field back into ParamTraits succeeds,
// * and ParamTraits is only automated for BytesAlwaysValidT<T> types.
// (BytesAlwaysValidT rejects bool and enum types, and only accepts int/float
// types, or array or std::arrays of such types)
// (Yes, bit-field fields are rejected by MutTiedFields too)
```
BytesAlwaysValidT<T> is the same as the IsTriviallySerializable<T> that
it replaces, however the emphasis is different, and should discourage
tagging structs as IsTriviallySerializable, since they more clearly
aren't BytesAlwaysValid.
Differential Revision: https://phabricator.services.mozilla.com/D151676
2022-08-09 21:01:55 +00:00
|
|
|
// -
|
2020-01-08 22:19:14 +00:00
|
|
|
|
Bug 1778808 - Use stricter TiedFields instead of IsTriviallySerializable in WebGL's QueueParamTraits. r=lsalzman,nika
```
// We guarantee our robustness via these requirements:
// * Object.MutTiedFields() gives us a tuple,
// * where the combined sizeofs all field types sums to sizeof(Object),
// * (thus we know we are exhaustively listing all fields)
// * where feeding each field back into ParamTraits succeeds,
// * and ParamTraits is only automated for BytesAlwaysValidT<T> types.
// (BytesAlwaysValidT rejects bool and enum types, and only accepts int/float
// types, or array or std::arrays of such types)
// (Yes, bit-field fields are rejected by MutTiedFields too)
```
BytesAlwaysValidT<T> is the same as the IsTriviallySerializable<T> that
it replaces, however the emphasis is different, and should discourage
tagging structs as IsTriviallySerializable, since they more clearly
aren't BytesAlwaysValid.
Differential Revision: https://phabricator.services.mozilla.com/D151676
2022-08-09 21:01:55 +00:00
|
|
|
#define USE_TIED_FIELDS(T) \
|
|
|
|
template <> \
|
|
|
|
struct QueueParamTraits<T> : QueueParamTraits_TiedFields<T> {};
|
2020-01-08 22:19:14 +00:00
|
|
|
|
Bug 1778808 - Use stricter TiedFields instead of IsTriviallySerializable in WebGL's QueueParamTraits. r=lsalzman,nika
```
// We guarantee our robustness via these requirements:
// * Object.MutTiedFields() gives us a tuple,
// * where the combined sizeofs all field types sums to sizeof(Object),
// * (thus we know we are exhaustively listing all fields)
// * where feeding each field back into ParamTraits succeeds,
// * and ParamTraits is only automated for BytesAlwaysValidT<T> types.
// (BytesAlwaysValidT rejects bool and enum types, and only accepts int/float
// types, or array or std::arrays of such types)
// (Yes, bit-field fields are rejected by MutTiedFields too)
```
BytesAlwaysValidT<T> is the same as the IsTriviallySerializable<T> that
it replaces, however the emphasis is different, and should discourage
tagging structs as IsTriviallySerializable, since they more clearly
aren't BytesAlwaysValid.
Differential Revision: https://phabricator.services.mozilla.com/D151676
2022-08-09 21:01:55 +00:00
|
|
|
// -
|
2020-01-08 22:19:14 +00:00
|
|
|
|
Bug 1778808 - Use stricter TiedFields instead of IsTriviallySerializable in WebGL's QueueParamTraits. r=lsalzman,nika
```
// We guarantee our robustness via these requirements:
// * Object.MutTiedFields() gives us a tuple,
// * where the combined sizeofs all field types sums to sizeof(Object),
// * (thus we know we are exhaustively listing all fields)
// * where feeding each field back into ParamTraits succeeds,
// * and ParamTraits is only automated for BytesAlwaysValidT<T> types.
// (BytesAlwaysValidT rejects bool and enum types, and only accepts int/float
// types, or array or std::arrays of such types)
// (Yes, bit-field fields are rejected by MutTiedFields too)
```
BytesAlwaysValidT<T> is the same as the IsTriviallySerializable<T> that
it replaces, however the emphasis is different, and should discourage
tagging structs as IsTriviallySerializable, since they more clearly
aren't BytesAlwaysValid.
Differential Revision: https://phabricator.services.mozilla.com/D151676
2022-08-09 21:01:55 +00:00
|
|
|
USE_TIED_FIELDS(layers::RemoteTextureId)
|
|
|
|
USE_TIED_FIELDS(layers::RemoteTextureOwnerId)
|
|
|
|
USE_TIED_FIELDS(WebGLContextOptions)
|
|
|
|
USE_TIED_FIELDS(webgl::PixelUnpackStateWebgl)
|
|
|
|
USE_TIED_FIELDS(webgl::SwapChainOptions)
|
|
|
|
USE_TIED_FIELDS(webgl::ReadPixelsDesc)
|
|
|
|
USE_TIED_FIELDS(webgl::VertAttribPointerDesc)
|
|
|
|
USE_TIED_FIELDS(webgl::PackingInfo)
|
|
|
|
USE_TIED_FIELDS(webgl::TypedQuad)
|
|
|
|
USE_TIED_FIELDS(webgl::PixelPackingState)
|
|
|
|
USE_TIED_FIELDS(FloatOrInt)
|
2020-01-08 22:19:14 +00:00
|
|
|
|
Bug 1778808 - Use stricter TiedFields instead of IsTriviallySerializable in WebGL's QueueParamTraits. r=lsalzman,nika
```
// We guarantee our robustness via these requirements:
// * Object.MutTiedFields() gives us a tuple,
// * where the combined sizeofs all field types sums to sizeof(Object),
// * (thus we know we are exhaustively listing all fields)
// * where feeding each field back into ParamTraits succeeds,
// * and ParamTraits is only automated for BytesAlwaysValidT<T> types.
// (BytesAlwaysValidT rejects bool and enum types, and only accepts int/float
// types, or array or std::arrays of such types)
// (Yes, bit-field fields are rejected by MutTiedFields too)
```
BytesAlwaysValidT<T> is the same as the IsTriviallySerializable<T> that
it replaces, however the emphasis is different, and should discourage
tagging structs as IsTriviallySerializable, since they more clearly
aren't BytesAlwaysValid.
Differential Revision: https://phabricator.services.mozilla.com/D151676
2022-08-09 21:01:55 +00:00
|
|
|
} // namespace webgl
|
2020-01-08 22:19:14 +00:00
|
|
|
template <>
|
Bug 1778808 - Use stricter TiedFields instead of IsTriviallySerializable in WebGL's QueueParamTraits. r=lsalzman,nika
```
// We guarantee our robustness via these requirements:
// * Object.MutTiedFields() gives us a tuple,
// * where the combined sizeofs all field types sums to sizeof(Object),
// * (thus we know we are exhaustively listing all fields)
// * where feeding each field back into ParamTraits succeeds,
// * and ParamTraits is only automated for BytesAlwaysValidT<T> types.
// (BytesAlwaysValidT rejects bool and enum types, and only accepts int/float
// types, or array or std::arrays of such types)
// (Yes, bit-field fields are rejected by MutTiedFields too)
```
BytesAlwaysValidT<T> is the same as the IsTriviallySerializable<T> that
it replaces, however the emphasis is different, and should discourage
tagging structs as IsTriviallySerializable, since they more clearly
aren't BytesAlwaysValid.
Differential Revision: https://phabricator.services.mozilla.com/D151676
2022-08-09 21:01:55 +00:00
|
|
|
inline auto TiedFields<gfx::IntSize>(gfx::IntSize& a) {
|
|
|
|
return std::tie(a.width, a.height);
|
|
|
|
}
|
|
|
|
namespace webgl {
|
|
|
|
USE_TIED_FIELDS(gfx::IntSize)
|
2020-01-08 22:19:14 +00:00
|
|
|
|
Bug 1778808 - Use stricter TiedFields instead of IsTriviallySerializable in WebGL's QueueParamTraits. r=lsalzman,nika
```
// We guarantee our robustness via these requirements:
// * Object.MutTiedFields() gives us a tuple,
// * where the combined sizeofs all field types sums to sizeof(Object),
// * (thus we know we are exhaustively listing all fields)
// * where feeding each field back into ParamTraits succeeds,
// * and ParamTraits is only automated for BytesAlwaysValidT<T> types.
// (BytesAlwaysValidT rejects bool and enum types, and only accepts int/float
// types, or array or std::arrays of such types)
// (Yes, bit-field fields are rejected by MutTiedFields too)
```
BytesAlwaysValidT<T> is the same as the IsTriviallySerializable<T> that
it replaces, however the emphasis is different, and should discourage
tagging structs as IsTriviallySerializable, since they more clearly
aren't BytesAlwaysValid.
Differential Revision: https://phabricator.services.mozilla.com/D151676
2022-08-09 21:01:55 +00:00
|
|
|
// -
|
2020-01-08 22:19:14 +00:00
|
|
|
|
Bug 1778808 - Use stricter TiedFields instead of IsTriviallySerializable in WebGL's QueueParamTraits. r=lsalzman,nika
```
// We guarantee our robustness via these requirements:
// * Object.MutTiedFields() gives us a tuple,
// * where the combined sizeofs all field types sums to sizeof(Object),
// * (thus we know we are exhaustively listing all fields)
// * where feeding each field back into ParamTraits succeeds,
// * and ParamTraits is only automated for BytesAlwaysValidT<T> types.
// (BytesAlwaysValidT rejects bool and enum types, and only accepts int/float
// types, or array or std::arrays of such types)
// (Yes, bit-field fields are rejected by MutTiedFields too)
```
BytesAlwaysValidT<T> is the same as the IsTriviallySerializable<T> that
it replaces, however the emphasis is different, and should discourage
tagging structs as IsTriviallySerializable, since they more clearly
aren't BytesAlwaysValid.
Differential Revision: https://phabricator.services.mozilla.com/D151676
2022-08-09 21:01:55 +00:00
|
|
|
#undef USE_TIED_FIELDS
|
2020-07-21 22:57:01 +00:00
|
|
|
|
Bug 1778808 - Use stricter TiedFields instead of IsTriviallySerializable in WebGL's QueueParamTraits. r=lsalzman,nika
```
// We guarantee our robustness via these requirements:
// * Object.MutTiedFields() gives us a tuple,
// * where the combined sizeofs all field types sums to sizeof(Object),
// * (thus we know we are exhaustively listing all fields)
// * where feeding each field back into ParamTraits succeeds,
// * and ParamTraits is only automated for BytesAlwaysValidT<T> types.
// (BytesAlwaysValidT rejects bool and enum types, and only accepts int/float
// types, or array or std::arrays of such types)
// (Yes, bit-field fields are rejected by MutTiedFields too)
```
BytesAlwaysValidT<T> is the same as the IsTriviallySerializable<T> that
it replaces, however the emphasis is different, and should discourage
tagging structs as IsTriviallySerializable, since they more clearly
aren't BytesAlwaysValid.
Differential Revision: https://phabricator.services.mozilla.com/D151676
2022-08-09 21:01:55 +00:00
|
|
|
// -
|
2020-01-08 22:19:14 +00:00
|
|
|
|
Bug 1778808 - Use stricter TiedFields instead of IsTriviallySerializable in WebGL's QueueParamTraits. r=lsalzman,nika
```
// We guarantee our robustness via these requirements:
// * Object.MutTiedFields() gives us a tuple,
// * where the combined sizeofs all field types sums to sizeof(Object),
// * (thus we know we are exhaustively listing all fields)
// * where feeding each field back into ParamTraits succeeds,
// * and ParamTraits is only automated for BytesAlwaysValidT<T> types.
// (BytesAlwaysValidT rejects bool and enum types, and only accepts int/float
// types, or array or std::arrays of such types)
// (Yes, bit-field fields are rejected by MutTiedFields too)
```
BytesAlwaysValidT<T> is the same as the IsTriviallySerializable<T> that
it replaces, however the emphasis is different, and should discourage
tagging structs as IsTriviallySerializable, since they more clearly
aren't BytesAlwaysValid.
Differential Revision: https://phabricator.services.mozilla.com/D151676
2022-08-09 21:01:55 +00:00
|
|
|
template <class T>
|
|
|
|
struct QueueParamTraits<avec2<T>> : QueueParamTraits_TiedFields<avec2<T>> {};
|
2020-01-08 22:19:14 +00:00
|
|
|
|
Bug 1778808 - Use stricter TiedFields instead of IsTriviallySerializable in WebGL's QueueParamTraits. r=lsalzman,nika
```
// We guarantee our robustness via these requirements:
// * Object.MutTiedFields() gives us a tuple,
// * where the combined sizeofs all field types sums to sizeof(Object),
// * (thus we know we are exhaustively listing all fields)
// * where feeding each field back into ParamTraits succeeds,
// * and ParamTraits is only automated for BytesAlwaysValidT<T> types.
// (BytesAlwaysValidT rejects bool and enum types, and only accepts int/float
// types, or array or std::arrays of such types)
// (Yes, bit-field fields are rejected by MutTiedFields too)
```
BytesAlwaysValidT<T> is the same as the IsTriviallySerializable<T> that
it replaces, however the emphasis is different, and should discourage
tagging structs as IsTriviallySerializable, since they more clearly
aren't BytesAlwaysValid.
Differential Revision: https://phabricator.services.mozilla.com/D151676
2022-08-09 21:01:55 +00:00
|
|
|
template <class T>
|
|
|
|
struct QueueParamTraits<avec3<T>> : QueueParamTraits_TiedFields<avec3<T>> {};
|
2020-04-30 22:22:52 +00:00
|
|
|
|
Bug 1778808 - Use stricter TiedFields instead of IsTriviallySerializable in WebGL's QueueParamTraits. r=lsalzman,nika
```
// We guarantee our robustness via these requirements:
// * Object.MutTiedFields() gives us a tuple,
// * where the combined sizeofs all field types sums to sizeof(Object),
// * (thus we know we are exhaustively listing all fields)
// * where feeding each field back into ParamTraits succeeds,
// * and ParamTraits is only automated for BytesAlwaysValidT<T> types.
// (BytesAlwaysValidT rejects bool and enum types, and only accepts int/float
// types, or array or std::arrays of such types)
// (Yes, bit-field fields are rejected by MutTiedFields too)
```
BytesAlwaysValidT<T> is the same as the IsTriviallySerializable<T> that
it replaces, however the emphasis is different, and should discourage
tagging structs as IsTriviallySerializable, since they more clearly
aren't BytesAlwaysValid.
Differential Revision: https://phabricator.services.mozilla.com/D151676
2022-08-09 21:01:55 +00:00
|
|
|
// ---------------------------------------------------------------------
|
|
|
|
// Enums!
|
|
|
|
|
|
|
|
inline constexpr bool IsEnumCase(const webgl::AttribBaseType raw) {
|
|
|
|
switch (raw) {
|
|
|
|
case webgl::AttribBaseType::Boolean:
|
|
|
|
case webgl::AttribBaseType::Float:
|
|
|
|
case webgl::AttribBaseType::Int:
|
|
|
|
case webgl::AttribBaseType::Uint:
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2024-05-06 23:36:51 +00:00
|
|
|
static_assert(IsEnumCase(webgl::AttribBaseType(3)));
|
|
|
|
static_assert(!IsEnumCase(webgl::AttribBaseType(4)));
|
|
|
|
static_assert(!IsEnumCase(webgl::AttribBaseType(5)));
|
Bug 1778808 - Use stricter TiedFields instead of IsTriviallySerializable in WebGL's QueueParamTraits. r=lsalzman,nika
```
// We guarantee our robustness via these requirements:
// * Object.MutTiedFields() gives us a tuple,
// * where the combined sizeofs all field types sums to sizeof(Object),
// * (thus we know we are exhaustively listing all fields)
// * where feeding each field back into ParamTraits succeeds,
// * and ParamTraits is only automated for BytesAlwaysValidT<T> types.
// (BytesAlwaysValidT rejects bool and enum types, and only accepts int/float
// types, or array or std::arrays of such types)
// (Yes, bit-field fields are rejected by MutTiedFields too)
```
BytesAlwaysValidT<T> is the same as the IsTriviallySerializable<T> that
it replaces, however the emphasis is different, and should discourage
tagging structs as IsTriviallySerializable, since they more clearly
aren't BytesAlwaysValid.
Differential Revision: https://phabricator.services.mozilla.com/D151676
2022-08-09 21:01:55 +00:00
|
|
|
|
|
|
|
#define USE_IS_ENUM_CASE(T) \
|
|
|
|
template <> \
|
|
|
|
struct QueueParamTraits<T> : QueueParamTraits_IsEnumCase<T> {};
|
|
|
|
|
|
|
|
USE_IS_ENUM_CASE(webgl::AttribBaseType)
|
2023-04-01 00:33:25 +00:00
|
|
|
USE_IS_ENUM_CASE(webgl::ProvokingVertex)
|
Bug 1778808 - Use stricter TiedFields instead of IsTriviallySerializable in WebGL's QueueParamTraits. r=lsalzman,nika
```
// We guarantee our robustness via these requirements:
// * Object.MutTiedFields() gives us a tuple,
// * where the combined sizeofs all field types sums to sizeof(Object),
// * (thus we know we are exhaustively listing all fields)
// * where feeding each field back into ParamTraits succeeds,
// * and ParamTraits is only automated for BytesAlwaysValidT<T> types.
// (BytesAlwaysValidT rejects bool and enum types, and only accepts int/float
// types, or array or std::arrays of such types)
// (Yes, bit-field fields are rejected by MutTiedFields too)
```
BytesAlwaysValidT<T> is the same as the IsTriviallySerializable<T> that
it replaces, however the emphasis is different, and should discourage
tagging structs as IsTriviallySerializable, since they more clearly
aren't BytesAlwaysValid.
Differential Revision: https://phabricator.services.mozilla.com/D151676
2022-08-09 21:01:55 +00:00
|
|
|
|
|
|
|
#undef USE_IS_ENUM_CASE
|
|
|
|
|
|
|
|
// ---------------------------------------------------------------------
|
|
|
|
// Custom QueueParamTraits
|
2020-04-30 22:22:52 +00:00
|
|
|
|
2024-02-29 00:37:28 +00:00
|
|
|
template <typename T>
|
|
|
|
struct QueueParamTraits<Span<T>> {
|
|
|
|
template <typename U>
|
|
|
|
static bool Write(ProducerView<U>& view, const Span<T>& in) {
|
|
|
|
const auto& elemCount = in.size();
|
|
|
|
auto status = view.WriteParam(elemCount);
|
|
|
|
if (!status) return status;
|
|
|
|
|
|
|
|
if (!elemCount) return status;
|
|
|
|
status = view.WriteFromRange(Range<const T>{in});
|
|
|
|
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename U>
|
|
|
|
static bool Read(ConsumerView<U>& view, Span<const T>* const out) {
|
|
|
|
size_t elemCount = 0;
|
|
|
|
auto status = view.ReadParam(&elemCount);
|
|
|
|
if (!status) return status;
|
|
|
|
|
|
|
|
if (!elemCount) {
|
|
|
|
*out = {};
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto data = view.template ReadRange<const T>(elemCount);
|
|
|
|
if (!data) return false;
|
|
|
|
*out = Span{*data};
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2020-01-08 22:19:16 +00:00
|
|
|
template <>
|
2020-06-08 23:35:46 +00:00
|
|
|
struct QueueParamTraits<webgl::ContextLossReason>
|
|
|
|
: public ContiguousEnumSerializerInclusive<
|
|
|
|
webgl::ContextLossReason, webgl::ContextLossReason::None,
|
|
|
|
webgl::ContextLossReason::Guilty> {};
|
2020-01-08 22:19:16 +00:00
|
|
|
|
|
|
|
template <typename V, typename E>
|
2020-04-30 22:21:45 +00:00
|
|
|
struct QueueParamTraits<Result<V, E>> {
|
2020-01-08 22:19:16 +00:00
|
|
|
using T = Result<V, E>;
|
|
|
|
|
2020-04-30 22:23:02 +00:00
|
|
|
template <typename U>
|
2021-09-11 02:11:11 +00:00
|
|
|
static bool Write(ProducerView<U>& aProducerView, const T& aArg) {
|
2020-01-08 22:19:16 +00:00
|
|
|
const auto ok = aArg.isOk();
|
|
|
|
auto status = aProducerView.WriteParam(ok);
|
|
|
|
if (!status) return status;
|
|
|
|
if (ok) {
|
|
|
|
status = aProducerView.WriteParam(aArg.unwrap());
|
|
|
|
} else {
|
|
|
|
status = aProducerView.WriteParam(aArg.unwrapErr());
|
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2020-04-30 22:23:02 +00:00
|
|
|
template <typename U>
|
2021-09-11 02:11:11 +00:00
|
|
|
static bool Read(ConsumerView<U>& aConsumerView, T* aArg) {
|
2020-01-08 22:19:16 +00:00
|
|
|
bool ok;
|
|
|
|
auto status = aConsumerView.ReadParam(&ok);
|
|
|
|
if (!status) return status;
|
|
|
|
if (ok) {
|
|
|
|
V val;
|
|
|
|
status = aConsumerView.ReadParam(&val);
|
|
|
|
*aArg = val;
|
|
|
|
} else {
|
|
|
|
E val;
|
|
|
|
status = aConsumerView.ReadParam(&val);
|
|
|
|
*aArg = Err(val);
|
|
|
|
}
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <>
|
2020-04-30 22:21:45 +00:00
|
|
|
struct QueueParamTraits<std::string> {
|
2020-01-08 22:19:16 +00:00
|
|
|
using T = std::string;
|
|
|
|
|
2020-04-30 22:23:02 +00:00
|
|
|
template <typename U>
|
2021-09-11 02:11:11 +00:00
|
|
|
static bool Write(ProducerView<U>& aProducerView, const T& aArg) {
|
2020-09-16 07:16:48 +00:00
|
|
|
const auto size = aArg.size();
|
|
|
|
auto status = aProducerView.WriteParam(size);
|
2020-01-08 22:19:16 +00:00
|
|
|
if (!status) return status;
|
2020-09-16 07:16:48 +00:00
|
|
|
status = aProducerView.WriteFromRange(Range<const char>{aArg.data(), size});
|
2020-01-08 22:19:16 +00:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2020-04-30 22:23:02 +00:00
|
|
|
template <typename U>
|
2021-09-11 02:11:11 +00:00
|
|
|
static bool Read(ConsumerView<U>& aConsumerView, T* aArg) {
|
2020-01-08 22:19:16 +00:00
|
|
|
size_t size;
|
|
|
|
auto status = aConsumerView.ReadParam(&size);
|
|
|
|
if (!status) return status;
|
|
|
|
|
2020-09-16 07:16:48 +00:00
|
|
|
const auto view = aConsumerView.template ReadRange<char>(size);
|
2021-09-11 02:11:11 +00:00
|
|
|
if (!view) return false;
|
2020-09-16 07:16:48 +00:00
|
|
|
aArg->assign(view->begin().get(), size);
|
2020-01-08 22:19:16 +00:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <typename U>
|
2020-04-30 22:21:45 +00:00
|
|
|
struct QueueParamTraits<std::vector<U>> {
|
2020-04-30 22:22:52 +00:00
|
|
|
using T = std::vector<U>;
|
2020-01-08 22:19:16 +00:00
|
|
|
|
2020-04-30 22:23:02 +00:00
|
|
|
template <typename V>
|
2021-09-11 02:11:11 +00:00
|
|
|
static bool Write(ProducerView<V>& aProducerView, const T& aArg) {
|
2020-01-08 22:19:16 +00:00
|
|
|
auto status = aProducerView.WriteParam(aArg.size());
|
|
|
|
if (!status) return status;
|
2020-07-22 08:41:10 +00:00
|
|
|
|
|
|
|
for (const auto& cur : aArg) {
|
|
|
|
status = aProducerView.WriteParam(cur);
|
|
|
|
if (!status) return status;
|
|
|
|
}
|
2020-01-08 22:19:16 +00:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2020-04-30 22:23:02 +00:00
|
|
|
template <typename V>
|
2021-09-11 02:11:11 +00:00
|
|
|
static bool Read(ConsumerView<V>& aConsumerView, T* aArg) {
|
2020-01-08 22:19:16 +00:00
|
|
|
size_t size;
|
|
|
|
auto status = aConsumerView.ReadParam(&size);
|
|
|
|
if (!status) return status;
|
|
|
|
aArg->resize(size);
|
2020-07-22 08:41:10 +00:00
|
|
|
|
|
|
|
for (auto& cur : *aArg) {
|
|
|
|
status = aConsumerView.ReadParam(&cur);
|
|
|
|
if (!status) return status;
|
|
|
|
}
|
2020-01-08 22:19:16 +00:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <>
|
2020-06-08 23:35:46 +00:00
|
|
|
struct QueueParamTraits<WebGLExtensionID>
|
|
|
|
: public ContiguousEnumSerializer<WebGLExtensionID,
|
|
|
|
WebGLExtensionID::ANGLE_instanced_arrays,
|
|
|
|
WebGLExtensionID::Max> {};
|
2020-01-08 22:19:14 +00:00
|
|
|
|
2020-04-30 22:22:52 +00:00
|
|
|
template <>
|
|
|
|
struct QueueParamTraits<CompileResult> {
|
|
|
|
using T = CompileResult;
|
|
|
|
|
2020-04-30 22:23:02 +00:00
|
|
|
template <typename U>
|
2021-09-11 02:11:11 +00:00
|
|
|
static bool Write(ProducerView<U>& aProducerView, const T& aArg) {
|
2020-04-30 22:22:52 +00:00
|
|
|
aProducerView.WriteParam(aArg.pending);
|
|
|
|
aProducerView.WriteParam(aArg.log);
|
|
|
|
aProducerView.WriteParam(aArg.translatedSource);
|
|
|
|
return aProducerView.WriteParam(aArg.success);
|
|
|
|
}
|
|
|
|
|
2020-04-30 22:23:02 +00:00
|
|
|
template <typename U>
|
2021-09-11 02:11:11 +00:00
|
|
|
static bool Read(ConsumerView<U>& aConsumerView, T* aArg) {
|
2020-06-08 23:42:37 +00:00
|
|
|
aConsumerView.ReadParam(&aArg->pending);
|
|
|
|
aConsumerView.ReadParam(&aArg->log);
|
|
|
|
aConsumerView.ReadParam(&aArg->translatedSource);
|
|
|
|
return aConsumerView.ReadParam(&aArg->success);
|
2020-04-30 22:22:52 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2020-08-25 16:10:21 +00:00
|
|
|
template <>
|
|
|
|
struct QueueParamTraits<mozilla::layers::TextureType>
|
|
|
|
: public ContiguousEnumSerializer<mozilla::layers::TextureType,
|
|
|
|
mozilla::layers::TextureType::Unknown,
|
|
|
|
mozilla::layers::TextureType::Last> {};
|
|
|
|
|
|
|
|
template <>
|
|
|
|
struct QueueParamTraits<mozilla::gfx::SurfaceFormat>
|
|
|
|
: public ContiguousEnumSerializerInclusive<
|
|
|
|
mozilla::gfx::SurfaceFormat, mozilla::gfx::SurfaceFormat::B8G8R8A8,
|
|
|
|
mozilla::gfx::SurfaceFormat::UNKNOWN> {};
|
|
|
|
|
|
|
|
template <>
|
|
|
|
struct QueueParamTraits<gfxAlphaType>
|
|
|
|
: public ContiguousEnumSerializerInclusive<
|
|
|
|
gfxAlphaType, gfxAlphaType::Opaque, gfxAlphaType::NonPremult> {};
|
|
|
|
|
2024-05-06 23:36:51 +00:00
|
|
|
// -
|
|
|
|
|
|
|
|
template <class Enum>
|
|
|
|
using WebIDLEnumQueueSerializer =
|
|
|
|
ContiguousEnumSerializerInclusive<Enum, ContiguousEnumValues<Enum>::min,
|
|
|
|
ContiguousEnumValues<Enum>::max>;
|
|
|
|
|
|
|
|
template <>
|
|
|
|
struct QueueParamTraits<dom::WebGLPowerPreference>
|
|
|
|
: public WebIDLEnumQueueSerializer<dom::WebGLPowerPreference> {};
|
|
|
|
template <>
|
|
|
|
struct QueueParamTraits<dom::PredefinedColorSpace>
|
|
|
|
: public WebIDLEnumQueueSerializer<dom::PredefinedColorSpace> {};
|
|
|
|
|
Bug 1778808 - Use stricter TiedFields instead of IsTriviallySerializable in WebGL's QueueParamTraits. r=lsalzman,nika
```
// We guarantee our robustness via these requirements:
// * Object.MutTiedFields() gives us a tuple,
// * where the combined sizeofs all field types sums to sizeof(Object),
// * (thus we know we are exhaustively listing all fields)
// * where feeding each field back into ParamTraits succeeds,
// * and ParamTraits is only automated for BytesAlwaysValidT<T> types.
// (BytesAlwaysValidT rejects bool and enum types, and only accepts int/float
// types, or array or std::arrays of such types)
// (Yes, bit-field fields are rejected by MutTiedFields too)
```
BytesAlwaysValidT<T> is the same as the IsTriviallySerializable<T> that
it replaces, however the emphasis is different, and should discourage
tagging structs as IsTriviallySerializable, since they more clearly
aren't BytesAlwaysValid.
Differential Revision: https://phabricator.services.mozilla.com/D151676
2022-08-09 21:01:55 +00:00
|
|
|
} // namespace webgl
|
|
|
|
} // namespace mozilla
|
2020-01-08 22:19:14 +00:00
|
|
|
|
2020-04-30 22:21:45 +00:00
|
|
|
#endif // WEBGLQUEUEPARAMTRAITS_H_
|