dom/canvas/WebGLParent.cpp

   1 /* -*- Mode: C++; tab-width: 20; 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 #include "WebGLParent.h"
   7
   8 #include "WebGLChild.h"
   9 #include "mozilla/layers/TextureClientSharedSurface.h"
  10 #include "ImageContainer.h"
  11 #include "HostWebGLContext.h"
  12 #include "WebGLMethodDispatcher.h"
  13
  14 namespace mozilla::dom {
  15
  16 mozilla::ipc::IPCResult WebGLParent::RecvInitialize(
  17     const webgl::InitContextDesc& desc, webgl::InitContextResult* const out) {
  18   mHost = HostWebGLContext::Create({nullptr, this}, desc, out);
  19
  20   if (!mHost) {
  21     MOZ_ASSERT(!out->error->empty());
  22   }
  23
  24   return IPC_OK();
  25 }
  26
  27 WebGLParent::WebGLParent(const dom::ContentParentId& aContentId)
  28     : mContentId(aContentId) {}
  29
  30 WebGLParent::~WebGLParent() = default;
  31
  32 // -
  33
  34 using IPCResult = mozilla::ipc::IPCResult;
  35
  36 IPCResult WebGLParent::RecvDispatchCommands(BigBuffer&& shmem,
  37                                             const uint64_t cmdsByteSize) {
  38   AUTO_PROFILER_LABEL("WebGLParent::RecvDispatchCommands", GRAPHICS);
  39   if (!mHost) {
  40     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
  41   }
  42
  43   const auto& gl = mHost->mContext->GL();
  44   const gl::GLContext::TlsScope tlsIsCurrent(gl);
  45
  46   MOZ_ASSERT(cmdsByteSize);
  47   const auto shmemBytes = Range<uint8_t>{shmem.AsSpan()};
  48   const auto byteSize = std::min<uint64_t>(shmemBytes.length(), cmdsByteSize);
  49   const auto cmdsBytes =
  50       Range<const uint8_t>{shmemBytes.begin(), shmemBytes.begin() + byteSize};
  51   auto view = webgl::RangeConsumerView{cmdsBytes};
  52
  53   if (kIsDebug) {
  54     const auto initialOffset =
  55         AlignmentOffset(kUniversalAlignment, cmdsBytes.begin().get());
  56     MOZ_ALWAYS_TRUE(!initialOffset);
  57   }
  58
  59   while (true) {
  60     view.AlignTo(kUniversalAlignment);
  61     size_t id = 0;
  62     if (!view.ReadParam(&id)) break;
  63
  64     const auto ok = WebGLMethodDispatcher<0>::DispatchCommand(*mHost, id, view);
  65     if (!ok) {
  66       const nsPrintfCString cstr(
  67           "DispatchCommand(id: %i) failed. Please file a bug!", int(id));
  68       const auto str = ToString(cstr);
  69       gfxCriticalError() << str;
  70       mHost->JsWarning(str);
  71       mHost->OnContextLoss(webgl::ContextLossReason::None);
  72       break;
  73     }
  74   }
  75
  76   return IPC_OK();
  77 }
  78
  79 IPCResult WebGLParent::RecvTexImage(const uint32_t level,
  80                                     const uint32_t respecFormat,
  81                                     const uvec3& offset,
  82                                     const webgl::PackingInfo& pi,
  83                                     webgl::TexUnpackBlobDesc&& desc) {
  84   if (!mHost) {
  85     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
  86   }
  87
  88   mHost->TexImage(level, respecFormat, offset, pi, desc);
  89   return IPC_OK();
  90 }
  91
  92 // -
  93
  94 mozilla::ipc::IPCResult WebGLParent::Recv__delete__() {
  95   mHost = nullptr;
  96   return IPC_OK();
  97 }
  98
  99 void WebGLParent::ActorDestroy(ActorDestroyReason aWhy) { mHost = nullptr; }
 100
 101 // -
 102
 103 IPCResult WebGLParent::RecvGetFrontBufferSnapshot(
 104     webgl::FrontBufferSnapshotIpc* const ret) {
 105   return GetFrontBufferSnapshot(ret, this);
 106 }
 107
 108 IPCResult WebGLParent::GetFrontBufferSnapshot(
 109     webgl::FrontBufferSnapshotIpc* const ret, IProtocol* aProtocol) {
 110   AUTO_PROFILER_LABEL("WebGLParent::GetFrontBufferSnapshot", GRAPHICS);
 111   *ret = {};
 112   if (!mHost) {
 113     return IPC_FAIL(aProtocol, "HostWebGLContext is not initialized.");
 114   }
 115
 116   const bool ok = [&]() {
 117     const auto maybeSize = mHost->FrontBufferSnapshotInto({});
 118     if (maybeSize) {
 119       const auto& surfSize = *maybeSize;
 120       const auto byteSize = 4 * surfSize.x * surfSize.y;
 121
 122       auto shmem = webgl::RaiiShmem::Alloc(aProtocol, byteSize);
 123       if (!shmem) {
 124         NS_WARNING("Failed to alloc shmem for RecvGetFrontBufferSnapshot.");
 125         return false;
 126       }
 127       const auto range = shmem.ByteRange();
 128       *ret = {surfSize, Some(shmem.Extract())};
 129
 130       if (!mHost->FrontBufferSnapshotInto(Some(range))) {
 131         gfxCriticalNote << "WebGLParent::RecvGetFrontBufferSnapshot: "
 132                            "FrontBufferSnapshotInto(some) failed after "
 133                            "FrontBufferSnapshotInto(none)";
 134         return false;
 135       }
 136     }
 137     return true;
 138   }();
 139   if (!ok) {
 140     // Zero means failure, as we still need to send any shmem we alloc.
 141     ret->surfSize = {0, 0};
 142   }
 143   return IPC_OK();
 144 }
 145
 146 IPCResult WebGLParent::RecvGetBufferSubData(const GLenum target,
 147                                             const uint64_t srcByteOffset,
 148                                             const uint64_t byteSize,
 149                                             Shmem* const ret) {
 150   AUTO_PROFILER_LABEL("WebGLParent::RecvGetBufferSubData", GRAPHICS);
 151   if (!mHost) {
 152     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 153   }
 154
 155   const auto allocSize = 1 + byteSize;
 156   auto shmem = webgl::RaiiShmem::Alloc(this, allocSize);
 157   if (!shmem) {
 158     NS_WARNING("Failed to alloc shmem for RecvGetBufferSubData.");
 159     return IPC_OK();
 160   }
 161
 162   const auto shmemRange = shmem.ByteRange();
 163   const auto dataRange =
 164       Range<uint8_t>{shmemRange.begin() + 1, shmemRange.end()};
 165
 166   // We need to always send the shmem:
 167   // https://bugzilla.mozilla.org/show_bug.cgi?id=1463831#c2
 168   const auto ok = mHost->GetBufferSubData(target, srcByteOffset, dataRange);
 169   *(shmemRange.begin().get()) = ok;
 170   *ret = shmem.Extract();
 171   return IPC_OK();
 172 }
 173
 174 IPCResult WebGLParent::RecvReadPixels(const webgl::ReadPixelsDesc& desc,
 175                                       ReadPixelsBuffer&& buffer,
 176                                       webgl::ReadPixelsResultIpc* const ret) {
 177   AUTO_PROFILER_LABEL("WebGLParent::RecvReadPixels", GRAPHICS);
 178   *ret = {};
 179   if (!mHost) {
 180     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 181   }
 182
 183   if (buffer.type() == ReadPixelsBuffer::TShmem) {
 184     const auto& shmem = buffer.get_Shmem();
 185     const auto range = shmem.Range<uint8_t>();
 186     const auto res = mHost->ReadPixelsInto(desc, range);
 187     *ret = {res, {}};
 188     return IPC_OK();
 189   }
 190
 191   const uint64_t byteSize = buffer.get_uint64_t();
 192   const auto allocSize = std::max<uint64_t>(1, byteSize);
 193   auto shmem = webgl::RaiiShmem::Alloc(this, allocSize);
 194   if (!shmem) {
 195     NS_WARNING("Failed to alloc shmem for RecvReadPixels.");
 196     return IPC_OK();
 197   }
 198
 199   const auto range = shmem.ByteRange();
 200
 201   const auto res = mHost->ReadPixelsInto(desc, range);
 202   *ret = {res, Some(shmem.Extract())};
 203   return IPC_OK();
 204 }
 205
 206 // -
 207
 208 IPCResult WebGLParent::RecvCheckFramebufferStatus(GLenum target,
 209                                                   GLenum* const ret) {
 210   if (!mHost) {
 211     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 212   }
 213
 214   *ret = mHost->CheckFramebufferStatus(target);
 215   return IPC_OK();
 216 }
 217
 218 IPCResult WebGLParent::RecvClientWaitSync(ObjectId id, GLbitfield flags,
 219                                           GLuint64 timeout, GLenum* const ret) {
 220   if (!mHost) {
 221     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 222   }
 223
 224   *ret = mHost->ClientWaitSync(id, flags, timeout);
 225   return IPC_OK();
 226 }
 227
 228 IPCResult WebGLParent::RecvCreateOpaqueFramebuffer(
 229     const ObjectId id, const OpaqueFramebufferOptions& options,
 230     bool* const ret) {
 231   if (!mHost) {
 232     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 233   }
 234
 235   *ret = mHost->CreateOpaqueFramebuffer(id, options);
 236   return IPC_OK();
 237 }
 238
 239 IPCResult WebGLParent::RecvDrawingBufferSize(uvec2* const ret) {
 240   if (!mHost) {
 241     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 242   }
 243
 244   *ret = mHost->DrawingBufferSize();
 245   return IPC_OK();
 246 }
 247
 248 IPCResult WebGLParent::RecvFinish() {
 249   if (!mHost) {
 250     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 251   }
 252
 253   mHost->Finish();
 254   return IPC_OK();
 255 }
 256
 257 IPCResult WebGLParent::RecvGetBufferParameter(GLenum target, GLenum pname,
 258                                               Maybe<double>* const ret) {
 259   if (!mHost) {
 260     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 261   }
 262
 263   *ret = mHost->GetBufferParameter(target, pname);
 264   return IPC_OK();
 265 }
 266
 267 IPCResult WebGLParent::RecvGetCompileResult(ObjectId id,
 268                                             webgl::CompileResult* const ret) {
 269   if (!mHost) {
 270     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 271   }
 272
 273   *ret = mHost->GetCompileResult(id);
 274   return IPC_OK();
 275 }
 276
 277 IPCResult WebGLParent::RecvGetError(GLenum* const ret) {
 278   if (!mHost) {
 279     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 280   }
 281
 282   *ret = mHost->GetError();
 283   return IPC_OK();
 284 }
 285
 286 IPCResult WebGLParent::RecvGetFragDataLocation(ObjectId id,
 287                                                const std::string& name,
 288                                                GLint* const ret) {
 289   if (!mHost) {
 290     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 291   }
 292
 293   *ret = mHost->GetFragDataLocation(id, name);
 294   return IPC_OK();
 295 }
 296
 297 IPCResult WebGLParent::RecvGetFramebufferAttachmentParameter(
 298     ObjectId id, GLenum attachment, GLenum pname, Maybe<double>* const ret) {
 299   if (!mHost) {
 300     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 301   }
 302
 303   *ret = mHost->GetFramebufferAttachmentParameter(id, attachment, pname);
 304   return IPC_OK();
 305 }
 306
 307 IPCResult WebGLParent::RecvGetFrontBuffer(
 308     ObjectId fb, const bool vr, Maybe<layers::SurfaceDescriptor>* const ret) {
 309   if (!mHost) {
 310     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 311   }
 312
 313   *ret = mHost->GetFrontBuffer(fb, vr);
 314   return IPC_OK();
 315 }
 316
 317 IPCResult WebGLParent::RecvGetIndexedParameter(GLenum target, GLuint index,
 318                                                Maybe<double>* const ret) {
 319   if (!mHost) {
 320     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 321   }
 322
 323   *ret = mHost->GetIndexedParameter(target, index);
 324   return IPC_OK();
 325 }
 326
 327 IPCResult WebGLParent::RecvGetInternalformatParameter(
 328     const GLenum target, const GLuint format, const GLuint pname,
 329     Maybe<std::vector<int32_t>>* const ret) {
 330   if (!mHost) {
 331     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 332   }
 333
 334   *ret = mHost->GetInternalformatParameter(target, format, pname);
 335   return IPC_OK();
 336 }
 337
 338 IPCResult WebGLParent::RecvGetLinkResult(ObjectId id,
 339                                          webgl::LinkResult* const ret) {
 340   if (!mHost) {
 341     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 342   }
 343
 344   *ret = mHost->GetLinkResult(id);
 345   return IPC_OK();
 346 }
 347
 348 IPCResult WebGLParent::RecvGetNumber(GLenum pname, Maybe<double>* const ret) {
 349   if (!mHost) {
 350     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 351   }
 352
 353   *ret = mHost->GetNumber(pname);
 354   return IPC_OK();
 355 }
 356
 357 IPCResult WebGLParent::RecvGetQueryParameter(ObjectId id, GLenum pname,
 358                                              Maybe<double>* const ret) {
 359   if (!mHost) {
 360     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 361   }
 362
 363   *ret = mHost->GetQueryParameter(id, pname);
 364   return IPC_OK();
 365 }
 366
 367 IPCResult WebGLParent::RecvGetRenderbufferParameter(ObjectId id, GLenum pname,
 368                                                     Maybe<double>* const ret) {
 369   if (!mHost) {
 370     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 371   }
 372
 373   *ret = mHost->GetRenderbufferParameter(id, pname);
 374   return IPC_OK();
 375 }
 376
 377 IPCResult WebGLParent::RecvGetSamplerParameter(ObjectId id, GLenum pname,
 378                                                Maybe<double>* const ret) {
 379   if (!mHost) {
 380     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 381   }
 382
 383   *ret = mHost->GetSamplerParameter(id, pname);
 384   return IPC_OK();
 385 }
 386
 387 IPCResult WebGLParent::RecvGetShaderPrecisionFormat(
 388     GLenum shaderType, GLenum precisionType,
 389     Maybe<webgl::ShaderPrecisionFormat>* const ret) {
 390   if (!mHost) {
 391     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 392   }
 393
 394   *ret = mHost->GetShaderPrecisionFormat(shaderType, precisionType);
 395   return IPC_OK();
 396 }
 397
 398 IPCResult WebGLParent::RecvGetString(GLenum pname,
 399                                      Maybe<std::string>* const ret) {
 400   if (!mHost) {
 401     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 402   }
 403
 404   *ret = mHost->GetString(pname);
 405   return IPC_OK();
 406 }
 407
 408 IPCResult WebGLParent::RecvGetTexParameter(ObjectId id, GLenum pname,
 409                                            Maybe<double>* const ret) {
 410   if (!mHost) {
 411     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 412   }
 413
 414   *ret = mHost->GetTexParameter(id, pname);
 415   return IPC_OK();
 416 }
 417
 418 IPCResult WebGLParent::RecvGetUniform(ObjectId id, uint32_t loc,
 419                                       webgl::GetUniformData* const ret) {
 420   if (!mHost) {
 421     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 422   }
 423
 424   *ret = mHost->GetUniform(id, loc);
 425   return IPC_OK();
 426 }
 427
 428 IPCResult WebGLParent::RecvGetVertexAttrib(GLuint index, GLenum pname,
 429                                            Maybe<double>* const ret) {
 430   if (!mHost) {
 431     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 432   }
 433
 434   *ret = mHost->GetVertexAttrib(index, pname);
 435   return IPC_OK();
 436 }
 437
 438 IPCResult WebGLParent::RecvIsEnabled(GLenum cap, bool* const ret) {
 439   if (!mHost) {
 440     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 441   }
 442
 443   *ret = mHost->IsEnabled(cap);
 444   return IPC_OK();
 445 }
 446
 447 IPCResult WebGLParent::RecvOnMemoryPressure() {
 448   if (!mHost) {
 449     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 450   }
 451
 452   mHost->OnMemoryPressure();
 453   return IPC_OK();
 454 }
 455
 456 IPCResult WebGLParent::RecvValidateProgram(ObjectId id, bool* const ret) {
 457   if (!mHost) {
 458     return IPC_FAIL(this, "HostWebGLContext is not initialized.");
 459   }
 460
 461   *ret = mHost->ValidateProgram(id);
 462   return IPC_OK();
 463 }
 464
 465 }  // namespace mozilla::dom