corysanin/tubestation
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Backed out changeset da6ee86afe99 (bug 1955115) for causing build bustages in QueueParamTraits.h. CLOSED TREE

Browse Source
This commit is contained in:
Stanca Serban
2025-03-21 05:12:17 +02:00
parent f85046de9b
commit 3804c21d91
13 changed files with 109 additions and 234 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
dom/canvas/ClientWebGLContext.cpp
View File

@@ -2874,19 +2874,22 @@ already_AddRefed<WebGLShaderPrecisionFormatJS>
ClientWebGLContext::GetShaderPrecisionFormat(const GLenum shadertype,
const GLenum precisiontype) {
if (IsContextLost()) return nullptr;
const auto& shaderPrecisions = mNotLost->info.shaderPrecisions;
const auto args =
webgl::GetShaderPrecisionFormatArgs{shadertype, precisiontype};
const auto found = MaybeFind(shaderPrecisions, args);
if (!found) {
EnqueueError(
LOCAL_GL_INVALID_ENUM, "Bad shaderType (%s) or precisionType (%s)",
EnumString(shadertype).c_str(), EnumString(precisiontype).c_str());
return nullptr;
const auto info = [&]() {
const auto& inProcess = mNotLost->inProcess;
if (inProcess) {
return inProcess->GetShaderPrecisionFormat(shadertype, precisiontype);
}
const auto& child = mNotLost->outOfProcess;
child->FlushPendingCmds();
Maybe<webgl::ShaderPrecisionFormat> ret;
if (!child->SendGetShaderPrecisionFormat(shadertype, precisiontype, &ret)) {
ret.reset();
}
return ret;
}();
return AsAddRefed(new WebGLShaderPrecisionFormatJS(*found));
if (!info) return nullptr;
return AsAddRefed(new WebGLShaderPrecisionFormatJS(*info));
}
void ClientWebGLContext::BlendColor(GLclampf r, GLclampf g, GLclampf b,

5
dom/canvas/HostWebGLContext.h
View File

@@ -407,6 +407,11 @@ class HostWebGLContext final : public SupportsWeakPtr {
return mContext->GetRenderbufferParameter(*obj, pname);
}
Maybe<webgl::ShaderPrecisionFormat> GetShaderPrecisionFormat(
GLenum shaderType, GLenum precisionType) const {
return mContext->GetShaderPrecisionFormat(shaderType, precisionType);
}
webgl::GetUniformData GetUniform(ObjectId id, uint32_t loc) const {
const auto obj = ById<WebGLProgram>(id);
if (!obj) return {};

2
dom/canvas/PWebGL.ipdl
View File

@@ -95,6 +95,8 @@ parent:
sync GetQueryParameter(uint64_t id, uint32_t pname) returns (double? ret);
sync GetRenderbufferParameter(uint64_t id, uint32_t pname) returns (double? ret);
sync GetSamplerParameter(uint64_t id, uint32_t pname) returns (double? ret);
sync GetShaderPrecisionFormat(
uint32_t shaderType, uint32_t precisionType) returns (ShaderPrecisionFormat? ret);
sync GetString(uint32_t pname) returns (string? ret);
sync GetTexParameter(uint64_t id, uint32_t pname) returns (double? ret);
sync GetUniform(uint64_t id, uint32_t loc) returns (GetUniformData ret);

72
dom/canvas/ParamTraits_STL.h
View File

@@ -78,78 +78,6 @@ struct ParamTraits<std::optional<U>> final {
}
};
// -
template <class A, class B>
struct ParamTraits<std::pair<A, B>> final {
using T = std::pair<A, B>;
static void Write(MessageWriter* const writer, const T& in) {
WriteParam(writer, in.first);
WriteParam(writer, in.second);
}
static bool Read(MessageReader* const reader, T* const out) {
bool ok = true;
ok = ok && ReadParam(reader, &out->first);
ok = ok && ReadParam(reader, &out->second);
return ok;
}
};
// -
template <class K, class V, class H, class E>
struct ParamTraits<std::unordered_map<K, V, H, E>> final {
using T = std::unordered_map<K, V, H, E>;
static void Write(MessageWriter* const writer, const T& in) {
const auto size = uint64_t{in.size()};
WriteParam(writer, size);
for (const auto& pair : in) {
WriteParam(writer, pair);
}
}
static bool Read(MessageReader* const reader, T* const out) {
out->clear();
auto size = uint64_t{};
if (!ReadParam(reader, &size)) return false;
out->reserve(static_cast<size_t>(size));
for (const auto _ : mozilla::IntegerRange(size)) {
auto pair = std::pair<K, V>{};
if (!ReadParam(reader, &pair)) return false;
out->insert(pair);
}
return true;
}
};
// -
// template <class... T>
// struct ParamTraits<std::tuple<T...>> final {
// using T = std::tuple<T...>;
//
// static void Write(MessageWriter* const writer, const T& in) {
// mozilla::MapTuple(aArg, [&](const auto& field) {
// WriteParam(writer, field);
// return true; // ignored
// });
// }
//
// static bool Read(MessageReader* const reader, T* const out) {
// bool ok = true;
// mozilla::MapTuple(*aArg, [&](auto& field) {
// ok = ok && ReadParam(reader, &field);
// return true; // ignored
// });
// return ok;
// }
// };
} // namespace IPC
#endif

59
dom/canvas/QueueParamTraits.h
View File

@@ -752,65 +752,6 @@ struct QueueParamTraits<std::pair<TypeA, TypeB>> {
}
};
// -
template <class... T>
struct QueueParamTraits<std::tuple<T...>> {
using ParamType = std::tuple<T...>;
template <typename U>
static bool Write(ProducerView<U>& aProducerView, const ParamType& aArg) {
bool ok = true;
mozilla::MapTuple(aArg, [&](const auto& field) {
ok &= aProducerView.WriteParam(field);
return true; // ignored
});
return ok;
}
template <typename U>
static bool Read(ConsumerView<U>& aConsumerView, ParamType* aArg) {
bool ok = true;
mozilla::MapTuple(*aArg, [&](auto& field) {
ok &= aConsumerView.ReadParam(&field);
return true; // ignored
});
return ok;
}
};
// -
template <class K, class V, class H, class E>
struct QueueParamTraits<std::unordered_map<K, V, H, E>> {
using ParamType = std::unordered_map<K, V, H, E>;
template <typename U>
static bool Write(ProducerView<U>& aProducerView, const ParamType& aArg) {
bool ok = aProducerView.WriteParam(uint64_t{aArg.size()});
for (const auto& pair : aArg) {
ok &= aProducerView.WriteParam(pair);
}
return ok;
}
template <typename U>
static bool Read(ConsumerView<U>& aConsumerView, ParamType* aArg) {
aArg->clear();
auto size = uint64_t{0};
if (!aConsumerView.ReadParam(&size)) return false;
aArg->reserve(size);
for (const auto i : IntegerRange(size)) {
auto pair = std::pair<K, V>{};
if (!aConsumerView.ReadParam(&pair)) return false;
aArg->insert(pair);
}
return true;
}
};
} // namespace mozilla::webgl
#endif // _QUEUEPARAMTRAITS_H_

36
dom/canvas/WebGLContext.cpp
View File

@@ -6,7 +6,6 @@
#include "WebGLContext.h"
#include <algorithm>
#include <array>
#include <bitset>
#include <queue>
#include <regex>
@@ -672,41 +671,6 @@ RefPtr<WebGLContext> WebGLContext::Create(HostWebGLContext* host,
// -
constexpr auto SHADER_TYPES = to_array<GLenum>({
LOCAL_GL_VERTEX_SHADER,
LOCAL_GL_FRAGMENT_SHADER,
});
constexpr auto PRECISIONS = to_array<GLenum>({
LOCAL_GL_LOW_FLOAT,
LOCAL_GL_MEDIUM_FLOAT,
LOCAL_GL_HIGH_FLOAT,
LOCAL_GL_LOW_INT,
LOCAL_GL_MEDIUM_INT,
LOCAL_GL_HIGH_INT,
});
for (const auto& shaderType : SHADER_TYPES) {
for (const auto& precisionType : PRECISIONS) {
auto spf = webgl::ShaderPrecisionFormat{};
GLint range[2] = {};
GLint precision = 0;
webgl->gl->fGetShaderPrecisionFormat(shaderType, precisionType, range,
&precision);
spf.rangeMin = LazyAssertedCast(range[0]);
spf.rangeMax = LazyAssertedCast(range[1]);
spf.precision = LazyAssertedCast(precision);
out->shaderPrecisions[{shaderType, precisionType}] = spf;
}
}
if (webgl->mDisableFragHighP) {
out->shaderPrecisions[{LOCAL_GL_FRAGMENT_SHADER, LOCAL_GL_HIGH_FLOAT}] = {};
out->shaderPrecisions[{LOCAL_GL_FRAGMENT_SHADER, LOCAL_GL_HIGH_INT}] = {};
}
// -
out->options = webgl->mOptions;
out->limits = *webgl->mLimits;
out->uploadableSdTypes = UploadableSdTypes();

3
dom/canvas/WebGLContext.h
View File

@@ -656,6 +656,9 @@ class WebGLContext : public VRefCounted, public SupportsWeakPtr {
GLenum pname) const;
webgl::LinkResult GetLinkResult(const WebGLProgram&) const;
Maybe<webgl::ShaderPrecisionFormat> GetShaderPrecisionFormat(
GLenum shadertype, GLenum precisiontype) const;
webgl::GetUniformData GetUniform(const WebGLProgram&, uint32_t loc) const;
void Hint(GLenum target, GLenum mode);

42
dom/canvas/WebGLContextGL.cpp
View File

@@ -1468,6 +1468,48 @@ void WebGLContext::CompileShader(WebGLShader& shader) {
shader.CompileShader();
}
Maybe<webgl::ShaderPrecisionFormat> WebGLContext::GetShaderPrecisionFormat(
GLenum shadertype, GLenum precisiontype) const {
const FuncScope funcScope(*this, "getShaderPrecisionFormat");
if (IsContextLost()) return Nothing();
switch (shadertype) {
case LOCAL_GL_FRAGMENT_SHADER:
case LOCAL_GL_VERTEX_SHADER:
break;
default:
ErrorInvalidEnumInfo("shadertype", shadertype);
return Nothing();
}
switch (precisiontype) {
case LOCAL_GL_LOW_FLOAT:
case LOCAL_GL_MEDIUM_FLOAT:
case LOCAL_GL_HIGH_FLOAT:
case LOCAL_GL_LOW_INT:
case LOCAL_GL_MEDIUM_INT:
case LOCAL_GL_HIGH_INT:
break;
default:
ErrorInvalidEnumInfo("precisiontype", precisiontype);
return Nothing();
}
GLint range[2], precision;
if (mDisableFragHighP && shadertype == LOCAL_GL_FRAGMENT_SHADER &&
(precisiontype == LOCAL_GL_HIGH_FLOAT ||
precisiontype == LOCAL_GL_HIGH_INT)) {
precision = 0;
range[0] = 0;
range[1] = 0;
} else {
gl->fGetShaderPrecisionFormat(shadertype, precisiontype, range, &precision);
}
return Some(webgl::ShaderPrecisionFormat{range[0], range[1], precision});
}
void WebGLContext::ShaderSource(WebGLShader& shader,
const std::string& source) const {
const FuncScope funcScope(*this, "shaderSource");

23
dom/canvas/WebGLIpdl.h
View File

@@ -274,10 +274,6 @@ struct ParamTraits<mozilla::webgl::OpaqueFramebufferOptions> final
: public ParamTraits_TiedFields<mozilla::webgl::OpaqueFramebufferOptions> {
};
template <>
struct ParamTraits<mozilla::webgl::ShaderPrecisionFormat> final
: public ParamTraits_TiedFields<mozilla::webgl::ShaderPrecisionFormat> {};
// -
template <>
@@ -493,6 +489,25 @@ struct ParamTraits<mozilla::webgl::ActiveUniformBlockInfo> final {
// -
template <>
struct ParamTraits<mozilla::webgl::ShaderPrecisionFormat> final {
using T = mozilla::webgl::ShaderPrecisionFormat;
static void Write(MessageWriter* const writer, const T& in) {
WriteParam(writer, in.rangeMin);
WriteParam(writer, in.rangeMax);
WriteParam(writer, in.precision);
}
static bool Read(MessageReader* const reader, T* const out) {
return ReadParam(reader, &out->rangeMin) &&
ReadParam(reader, &out->rangeMax) &&
ReadParam(reader, &out->precision);
}
};
// -
template <>
struct ParamTraits<mozilla::webgl::GetUniformData> final {
using T = mozilla::webgl::GetUniformData;

11
dom/canvas/WebGLParent.cpp
View File

@@ -414,6 +414,17 @@ IPCResult WebGLParent::RecvGetSamplerParameter(ObjectId id, GLenum pname,
return IPC_OK();
}
IPCResult WebGLParent::RecvGetShaderPrecisionFormat(
GLenum shaderType, GLenum precisionType,
Maybe<webgl::ShaderPrecisionFormat>* const ret) {
if (!mHost) {
return IPC_FAIL(this, "HostWebGLContext is not initialized.");
}
*ret = mHost->GetShaderPrecisionFormat(shaderType, precisionType);
return IPC_OK();
}
IPCResult WebGLParent::RecvGetString(GLenum pname,
Maybe<std::string>* const ret) {
if (!mHost) {

3
dom/canvas/WebGLParent.h
View File

@@ -97,6 +97,9 @@ class WebGLParent : public PWebGLParent, public SupportsWeakPtr {
Maybe<double>* ret);
IPCResult RecvGetSamplerParameter(ObjectId id, GLenum pname,
Maybe<double>* ret);
IPCResult RecvGetShaderPrecisionFormat(
GLenum shaderType, GLenum precisionType,
Maybe<webgl::ShaderPrecisionFormat>* ret);
IPCResult RecvGetString(GLenum pname, Maybe<std::string>* ret);
IPCResult RecvGetTexParameter(ObjectId id, GLenum pname, Maybe<double>* ret);
IPCResult RecvGetUniform(ObjectId id, uint32_t loc,

58
dom/canvas/WebGLTypes.h
View File

@@ -749,36 +749,6 @@ namespace webgl {
// -
using GetShaderPrecisionFormatArgs = std::tuple<GLenum, GLenum>;
template <class Tuple>
struct TupleStdHash {
size_t operator()(const Tuple& t) const {
size_t ret = 0;
mozilla::MapTuple(t, [&](const auto& field) {
using FieldT = std::remove_cv_t<std::remove_reference_t<decltype(field)>>;
ret ^= std::hash<FieldT>{}(field);
return true; // ignored
});
return ret;
}
};
struct ShaderPrecisionFormat final {
// highp float: [127, 127, 23]
// highp int: [31, 30, 0]
uint8_t rangeMin = 0; // highp float: +127 (meaning 2^-127)
uint8_t rangeMax = 0;
uint8_t precision = 0;
uint8_t _padding = 0;
auto MutTiedFields() {
return std::tie(rangeMin, rangeMax, precision, _padding);
}
};
// -
struct InitContextResult final {
Padded<std::string, 32> error; // MINGW 32-bit needs this padding.
WebGLContextOptions options;
@@ -787,13 +757,10 @@ struct InitContextResult final {
std::array<uint8_t, 3> _padding = {};
Limits limits;
EnumMask<layers::SurfaceDescriptor::Type> uploadableSdTypes;
std::unordered_map<GetShaderPrecisionFormatArgs, ShaderPrecisionFormat,
TupleStdHash<GetShaderPrecisionFormatArgs>>
shaderPrecisions;
auto MutTiedFields() {
return std::tie(error, options, vendor, optionalRenderableFormatBits,
_padding, limits, uploadableSdTypes, shaderPrecisions);
_padding, limits, uploadableSdTypes);
}
};
@@ -804,6 +771,12 @@ struct ErrorInfo final {
std::string info;
};
struct ShaderPrecisionFormat final {
GLint rangeMin = 0;
GLint rangeMax = 0;
GLint precision = 0;
};
// -
enum class LossStatus {
@@ -1383,23 +1356,6 @@ inline std::string ToStringWithCommas(uint64_t v) {
return Join(chunks, ",");
}
// -
// C++17 polyfill implementation from:
// https://en.cppreference.com/w/cpp/container/array/to_array
namespace detail {
template <class T, size_t N, size_t... I>
constexpr std::array<std::remove_cv_t<T>, N> to_array_impl(
T (&&a)[N], std::index_sequence<I...>) {
return {{std::move(a[I])...}};
}
} // namespace detail
template <class T, size_t N>
constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&&a)[N]) {
return detail::to_array_impl(std::move(a), std::make_index_sequence<N>{});
}
// -
namespace webgl {

2
ipc/ipdl/sync-messages.ini
View File

@@ -347,6 +347,8 @@ description = Reflection is cold code, but synchronous by spec.
description = Reflection is cold code, but synchronous by spec.
[PWebGL::GetSamplerParameter]
description = Reflection is cold code, but synchronous by spec.
[PWebGL::GetShaderPrecisionFormat]
description = Reflection is cold code, but synchronous by spec.
[PWebGL::GetString]
description = Reflection is cold code, but synchronous by spec.
[PWebGL::GetTexParameter]