dom/canvas/WebGLQueueParamTraits.h

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef WEBGLQUEUEPARAMTRAITS_H_
   7 #define WEBGLQUEUEPARAMTRAITS_H_
   8
   9 #include <type_traits>
  10
  11 #include "ipc/EnumSerializer.h"
  12 #include "mozilla/dom/ProducerConsumerQueue.h"
  13 #include "TexUnpackBlob.h"
  14 #include "WebGLContext.h"
  15 #include "WebGLTypes.h"
  16
  17 namespace mozilla {
  18
  19 namespace webgl {
  20 template <typename T>
  21 struct QueueParamTraits;
  22
  23 template <>
  24 struct IsTriviallySerializable<FloatOrInt> : std::true_type {};
  25
  26 template <>
  27 struct IsTriviallySerializable<webgl::ShaderPrecisionFormat> : std::true_type {
  28 };
  29
  30 template <>
  31 struct IsTriviallySerializable<WebGLContextOptions> : std::true_type {};
  32
  33 template <>
  34 struct IsTriviallySerializable<WebGLPixelStore> : std::true_type {};
  35
  36 template <>
  37 struct IsTriviallySerializable<WebGLTexImageData> : std::true_type {};
  38
  39 template <>
  40 struct IsTriviallySerializable<WebGLTexPboOffset> : std::true_type {};
  41
  42 template <>
  43 struct IsTriviallySerializable<webgl::ExtensionBits> : std::true_type {};
  44 template <>
  45 struct IsTriviallySerializable<webgl::GetUniformData> : std::true_type {};
  46
  47 template <>
  48 struct IsTriviallySerializable<mozilla::webgl::PackingInfo> : std::true_type {};
  49
  50 template <>
  51 struct IsTriviallySerializable<ICRData> : std::true_type {};
  52
  53 template <>
  54 struct IsTriviallySerializable<gfx::IntSize> : std::true_type {};
  55
  56 template <typename T>
  57 struct IsTriviallySerializable<avec2<T>> : std::true_type {};
  58 template <typename T>
  59 struct IsTriviallySerializable<avec3<T>> : std::true_type {};
  60
  61 template <>
  62 struct IsTriviallySerializable<webgl::TexUnpackBlob> : std::true_type {};
  63
  64 template <>
  65 struct IsTriviallySerializable<webgl::TypedQuad> : std::true_type {};
  66 template <>
  67 struct IsTriviallySerializable<webgl::VertAttribPointerDesc> : std::true_type {
  68 };
  69 template <>
  70 struct IsTriviallySerializable<webgl::ReadPixelsDesc> : std::true_type {};
  71 template <>
  72 struct IsTriviallySerializable<layers::SurfaceDescriptor> : std::true_type {};
  73
  74 template <typename T>
  75 struct QueueParamTraits<RawBuffer<T>> {
  76   using ParamType = RawBuffer<T>;
  77
  78   template <typename U>
  79   static QueueStatus Write(ProducerView<U>& view, const ParamType& in) {
  80     const auto& elemCount = in.size();
  81     auto status = view.WriteParam(elemCount);
  82     if (!status) return status;
  83     if (!elemCount) return status;
  84
  85     const auto& begin = in.begin();
  86     const bool hasData = static_cast<bool>(begin);
  87     status = view.WriteParam(hasData);
  88     if (!status) return status;
  89     if (!hasData) return status;
  90
  91     status = view.WriteFromRange(in.Data());
  92     return status;
  93   }
  94
  95   template <typename U>
  96   static QueueStatus Read(ConsumerView<U>& view, ParamType* const out) {
  97     size_t elemCount = 0;
  98     auto status = view.ReadParam(&elemCount);
  99     if (!status) return status;
 100     if (!elemCount) {
 101       *out = {};
 102       return QueueStatus::kSuccess;
 103     }
 104
 105     uint8_t hasData = 0;
 106     status = view.ReadParam(&hasData);
 107     if (!status) return status;
 108     if (!hasData) {
 109       auto temp = RawBuffer<T>{elemCount};
 110       *out = std::move(temp);
 111       return QueueStatus::kSuccess;
 112     }
 113
 114     auto data = view.template ReadRange<T>(elemCount);
 115     if (!data) return QueueStatus::kTooSmall;
 116     *out = std::move(RawBuffer<T>{*data});
 117     return QueueStatus::kSuccess;
 118   }
 119 };
 120
 121 template <>
 122 struct QueueParamTraits<webgl::ContextLossReason>
 123     : public ContiguousEnumSerializerInclusive<
 124           webgl::ContextLossReason, webgl::ContextLossReason::None,
 125           webgl::ContextLossReason::Guilty> {};
 126
 127 template <typename V, typename E>
 128 struct QueueParamTraits<Result<V, E>> {
 129   using T = Result<V, E>;
 130
 131   template <typename U>
 132   static QueueStatus Write(ProducerView<U>& aProducerView, const T& aArg) {
 133     const auto ok = aArg.isOk();
 134     auto status = aProducerView.WriteParam(ok);
 135     if (!status) return status;
 136     if (ok) {
 137       status = aProducerView.WriteParam(aArg.unwrap());
 138     } else {
 139       status = aProducerView.WriteParam(aArg.unwrapErr());
 140     }
 141     return status;
 142   }
 143
 144   template <typename U>
 145   static QueueStatus Read(ConsumerView<U>& aConsumerView, T* aArg) {
 146     bool ok;
 147     auto status = aConsumerView.ReadParam(&ok);
 148     if (!status) return status;
 149     if (ok) {
 150       V val;
 151       status = aConsumerView.ReadParam(&val);
 152       *aArg = val;
 153     } else {
 154       E val;
 155       status = aConsumerView.ReadParam(&val);
 156       *aArg = Err(val);
 157     }
 158     return status;
 159   }
 160 };
 161
 162 template <>
 163 struct QueueParamTraits<std::string> {
 164   using T = std::string;
 165
 166   template <typename U>
 167   static QueueStatus Write(ProducerView<U>& aProducerView, const T& aArg) {
 168     const auto size = aArg.size();
 169     auto status = aProducerView.WriteParam(size);
 170     if (!status) return status;
 171     status = aProducerView.WriteFromRange(Range<const char>{aArg.data(), size});
 172     return status;
 173   }
 174
 175   template <typename U>
 176   static QueueStatus Read(ConsumerView<U>& aConsumerView, T* aArg) {
 177     size_t size;
 178     auto status = aConsumerView.ReadParam(&size);
 179     if (!status) return status;
 180
 181     const auto view = aConsumerView.template ReadRange<char>(size);
 182     if (!view) return QueueStatus::kFatalError;
 183     aArg->assign(view->begin().get(), size);
 184     return status;
 185   }
 186 };
 187
 188 template <typename U>
 189 struct QueueParamTraits<std::vector<U>> {
 190   using T = std::vector<U>;
 191
 192   template <typename V>
 193   static QueueStatus Write(ProducerView<V>& aProducerView, const T& aArg) {
 194     auto status = aProducerView.WriteParam(aArg.size());
 195     if (!status) return status;
 196
 197     for (const auto& cur : aArg) {
 198       status = aProducerView.WriteParam(cur);
 199       if (!status) return status;
 200     }
 201     return status;
 202   }
 203
 204   template <typename V>
 205   static QueueStatus Read(ConsumerView<V>& aConsumerView, T* aArg) {
 206     size_t size;
 207     auto status = aConsumerView.ReadParam(&size);
 208     if (!status) return status;
 209     aArg->resize(size);
 210
 211     for (auto& cur : *aArg) {
 212       status = aConsumerView.ReadParam(&cur);
 213       if (!status) return status;
 214     }
 215     return status;
 216   }
 217 };
 218
 219 template <>
 220 struct QueueParamTraits<WebGLExtensionID>
 221     : public ContiguousEnumSerializer<WebGLExtensionID,
 222                                       WebGLExtensionID::ANGLE_instanced_arrays,
 223                                       WebGLExtensionID::Max> {};
 224
 225 template <>
 226 struct QueueParamTraits<CompileResult> {
 227   using T = CompileResult;
 228
 229   template <typename U>
 230   static QueueStatus Write(ProducerView<U>& aProducerView, const T& aArg) {
 231     aProducerView.WriteParam(aArg.pending);
 232     aProducerView.WriteParam(aArg.log);
 233     aProducerView.WriteParam(aArg.translatedSource);
 234     return aProducerView.WriteParam(aArg.success);
 235   }
 236
 237   template <typename U>
 238   static QueueStatus Read(ConsumerView<U>& aConsumerView, T* aArg) {
 239     aConsumerView.ReadParam(&aArg->pending);
 240     aConsumerView.ReadParam(&aArg->log);
 241     aConsumerView.ReadParam(&aArg->translatedSource);
 242     return aConsumerView.ReadParam(&aArg->success);
 243   }
 244 };
 245
 246 template <>
 247 struct QueueParamTraits<mozilla::layers::TextureType>
 248     : public ContiguousEnumSerializer<mozilla::layers::TextureType,
 249                                       mozilla::layers::TextureType::Unknown,
 250                                       mozilla::layers::TextureType::Last> {};
 251
 252 template <>
 253 struct QueueParamTraits<mozilla::gfx::SurfaceFormat>
 254     : public ContiguousEnumSerializerInclusive<
 255           mozilla::gfx::SurfaceFormat, mozilla::gfx::SurfaceFormat::B8G8R8A8,
 256           mozilla::gfx::SurfaceFormat::UNKNOWN> {};
 257
 258 template <>
 259 struct QueueParamTraits<gfxAlphaType>
 260     : public ContiguousEnumSerializerInclusive<
 261           gfxAlphaType, gfxAlphaType::Opaque, gfxAlphaType::NonPremult> {};
 262
 263 }  // namespace webgl
 264 }  // namespace mozilla
 265
 266 #endif  // WEBGLQUEUEPARAMTRAITS_H_