Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 6891 insertions, 0 deletions

diff --git a/dom/canvas/ClientWebGLContext.cpp b/dom/canvas/ClientWebGLContext.cpp
new file mode 100644
index 0000000000..bde265f9a0
--- /dev/null
+++ b/dom/canvas/ClientWebGLContext.cpp
@@ -0,0 +1,6891 @@
+/* -*- Mode: C++; tab-width: 20; 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/. */
+
+#include "ClientWebGLContext.h"
+
+#include <bitset>
+
+#include "ClientWebGLExtensions.h"
+#include "gfxCrashReporterUtils.h"
+#include "HostWebGLContext.h"
+#include "js/PropertyAndElement.h"  // JS_DefineElement
+#include "js/ScalarType.h"          // js::Scalar::Type
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/ToJSValue.h"
+#include "mozilla/dom/TypedArray.h"
+#include "mozilla/dom/WebGLContextEvent.h"
+#include "mozilla/dom/WorkerCommon.h"
+#include "mozilla/EnumeratedRange.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/gfx/CanvasManagerChild.h"
+#include "mozilla/ipc/Shmem.h"
+#include "mozilla/gfx/Swizzle.h"
+#include "mozilla/layers/CompositableForwarder.h"
+#include "mozilla/layers/CompositorBridgeChild.h"
+#include "mozilla/layers/ImageBridgeChild.h"
+#include "mozilla/layers/OOPCanvasRenderer.h"
+#include "mozilla/layers/TextureClientSharedSurface.h"
+#include "mozilla/layers/WebRenderUserData.h"
+#include "mozilla/layers/WebRenderCanvasRenderer.h"
+#include "mozilla/ResultVariant.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/StaticPrefs_webgl.h"
+#include "nsContentUtils.h"
+#include "nsDisplayList.h"
+#include "TexUnpackBlob.h"
+#include "WebGLMethodDispatcher.h"
+#include "WebGLChild.h"
+#include "WebGLTextureUpload.h"
+#include "WebGLValidateStrings.h"
+
+namespace mozilla {
+
+namespace webgl {
+std::string SanitizeRenderer(const std::string&);
+}  // namespace webgl
+
+// -
+
+webgl::NotLostData::NotLostData(ClientWebGLContext& _context)
+    : context(_context) {}
+
+webgl::NotLostData::~NotLostData() {
+  if (outOfProcess) {
+    outOfProcess->Destroy();
+  }
+}
+
+// -
+
+bool webgl::ObjectJS::ValidateForContext(
+    const ClientWebGLContext& targetContext, const char* const argName) const {
+  if (!IsForContext(targetContext)) {
+    targetContext.EnqueueError(
+        LOCAL_GL_INVALID_OPERATION,
+        "`%s` is from a different (or lost) WebGL context.", argName);
+    return false;
+  }
+  return true;
+}
+
+void webgl::ObjectJS::WarnInvalidUse(const ClientWebGLContext& targetContext,
+                                     const char* const argName) const {
+  if (!ValidateForContext(targetContext, argName)) return;
+
+  const auto errEnum = ErrorOnDeleted();
+  targetContext.EnqueueError(errEnum, "Object `%s` is already deleted.",
+                             argName);
+}
+
+// -
+
+WebGLBufferJS::~WebGLBufferJS() {
+  const auto webgl = Context();
+  if (webgl) {
+    webgl->DeleteBuffer(this);
+  }
+}
+
+WebGLFramebufferJS::~WebGLFramebufferJS() {
+  const auto webgl = Context();
+  if (webgl) {
+    webgl->DeleteFramebuffer(this);
+  }
+}
+
+WebGLQueryJS::~WebGLQueryJS() {
+  const auto webgl = Context();
+  if (webgl) {
+    webgl->DeleteQuery(this);
+  }
+}
+
+WebGLRenderbufferJS::~WebGLRenderbufferJS() {
+  const auto webgl = Context();
+  if (webgl) {
+    webgl->DeleteRenderbuffer(this);
+  }
+}
+
+WebGLSamplerJS::~WebGLSamplerJS() {
+  const auto webgl = Context();
+  if (webgl) {
+    webgl->DeleteSampler(this);
+  }
+}
+
+WebGLSyncJS::~WebGLSyncJS() {
+  const auto webgl = Context();
+  if (webgl) {
+    webgl->DeleteSync(this);
+  }
+}
+
+WebGLTextureJS::~WebGLTextureJS() {
+  const auto webgl = Context();
+  if (webgl) {
+    webgl->DeleteTexture(this);
+  }
+}
+
+WebGLTransformFeedbackJS::~WebGLTransformFeedbackJS() {
+  const auto webgl = Context();
+  if (webgl) {
+    webgl->DeleteTransformFeedback(this);
+  }
+}
+
+WebGLVertexArrayJS::~WebGLVertexArrayJS() {
+  const auto webgl = Context();
+  if (webgl) {
+    webgl->DeleteVertexArray(this);
+  }
+}
+
+// -
+
+static bool GetJSScalarFromGLType(GLenum type,
+                                  js::Scalar::Type* const out_scalarType) {
+  switch (type) {
+    case LOCAL_GL_BYTE:
+      *out_scalarType = js::Scalar::Int8;
+      return true;
+
+    case LOCAL_GL_UNSIGNED_BYTE:
+      *out_scalarType = js::Scalar::Uint8;
+      return true;
+
+    case LOCAL_GL_SHORT:
+      *out_scalarType = js::Scalar::Int16;
+      return true;
+
+    case LOCAL_GL_HALF_FLOAT:
+    case LOCAL_GL_HALF_FLOAT_OES:
+    case LOCAL_GL_UNSIGNED_SHORT:
+    case LOCAL_GL_UNSIGNED_SHORT_4_4_4_4:
+    case LOCAL_GL_UNSIGNED_SHORT_5_5_5_1:
+    case LOCAL_GL_UNSIGNED_SHORT_5_6_5:
+      *out_scalarType = js::Scalar::Uint16;
+      return true;
+
+    case LOCAL_GL_UNSIGNED_INT:
+    case LOCAL_GL_UNSIGNED_INT_2_10_10_10_REV:
+    case LOCAL_GL_UNSIGNED_INT_5_9_9_9_REV:
+    case LOCAL_GL_UNSIGNED_INT_10F_11F_11F_REV:
+    case LOCAL_GL_UNSIGNED_INT_24_8:
+      *out_scalarType = js::Scalar::Uint32;
+      return true;
+    case LOCAL_GL_INT:
+      *out_scalarType = js::Scalar::Int32;
+      return true;
+
+    case LOCAL_GL_FLOAT:
+      *out_scalarType = js::Scalar::Float32;
+      return true;
+
+    default:
+      return false;
+  }
+}
+
+ClientWebGLContext::ClientWebGLContext(const bool webgl2)
+    : mIsWebGL2(webgl2),
+      mExtLoseContext(new ClientWebGLExtensionLoseContext(*this)) {}
+
+ClientWebGLContext::~ClientWebGLContext() { RemovePostRefreshObserver(); }
+
+void ClientWebGLContext::JsWarning(const std::string& utf8) const {
+  nsIGlobalObject* global = nullptr;
+  if (mCanvasElement) {
+    mozilla::dom::Document* doc = mCanvasElement->OwnerDoc();
+    if (doc) {
+      global = doc->GetScopeObject();
+    }
+  } else if (mOffscreenCanvas) {
+    global = mOffscreenCanvas->GetOwnerGlobal();
+  }
+
+  dom::AutoJSAPI api;
+  if (!api.Init(global)) {
+    return;
+  }
+  const auto& cx = api.cx();
+  JS::WarnUTF8(cx, "%s", utf8.c_str());
+}
+
+void AutoJsWarning(const std::string& utf8) {
+  if (NS_IsMainThread()) {
+    const AutoJSContext cx;
+    JS::WarnUTF8(cx, "%s", utf8.c_str());
+    return;
+  }
+
+  JSContext* cx = dom::GetCurrentWorkerThreadJSContext();
+  if (NS_WARN_IF(!cx)) {
+    return;
+  }
+
+  JS::WarnUTF8(cx, "%s", utf8.c_str());
+}
+
+// ---------
+
+bool ClientWebGLContext::DispatchEvent(const nsAString& eventName) const {
+  const auto kCanBubble = CanBubble::eYes;
+  const auto kIsCancelable = Cancelable::eYes;
+  bool useDefaultHandler = true;
+
+  if (mCanvasElement) {
+    nsContentUtils::DispatchTrustedEvent(mCanvasElement->OwnerDoc(),
+                                         mCanvasElement, eventName, kCanBubble,
+                                         kIsCancelable, &useDefaultHandler);
+  } else if (mOffscreenCanvas) {
+    // OffscreenCanvas case
+    RefPtr<dom::Event> event =
+        new dom::Event(mOffscreenCanvas, nullptr, nullptr);
+    event->InitEvent(eventName, kCanBubble, kIsCancelable);
+    event->SetTrusted(true);
+    useDefaultHandler = mOffscreenCanvas->DispatchEvent(
+        *event, dom::CallerType::System, IgnoreErrors());
+  }
+  return useDefaultHandler;
+}
+
+// -
+
+void ClientWebGLContext::EmulateLoseContext() const {
+  const FuncScope funcScope(*this, "loseContext");
+  if (mLossStatus != webgl::LossStatus::Ready) {
+    JsWarning("loseContext: Already lost.");
+    if (!mNextError) {
+      mNextError = LOCAL_GL_INVALID_OPERATION;
+    }
+    return;
+  }
+  OnContextLoss(webgl::ContextLossReason::Manual);
+}
+
+void ClientWebGLContext::OnContextLoss(
+    const webgl::ContextLossReason reason) const {
+  JsWarning("WebGL context was lost.");
+
+  if (mNotLost) {
+    for (const auto& ext : mNotLost->extensions) {
+      if (!ext) continue;
+      ext->mContext = nullptr;  // Detach.
+    }
+    mNotLost = {};  // Lost now!
+    mNextError = LOCAL_GL_CONTEXT_LOST_WEBGL;
+  }
+
+  switch (reason) {
+    case webgl::ContextLossReason::Guilty:
+      mLossStatus = webgl::LossStatus::LostForever;
+      break;
+
+    case webgl::ContextLossReason::None:
+      mLossStatus = webgl::LossStatus::Lost;
+      break;
+
+    case webgl::ContextLossReason::Manual:
+      mLossStatus = webgl::LossStatus::LostManually;
+      break;
+  }
+
+  const auto weak = WeakPtr<const ClientWebGLContext>(this);
+  const auto fnRun = [weak]() {
+    const auto strong = RefPtr<const ClientWebGLContext>(weak);
+    if (!strong) return;
+    strong->Event_webglcontextlost();
+  };
+  already_AddRefed<mozilla::CancelableRunnable> runnable =
+      NS_NewCancelableRunnableFunction("enqueue Event_webglcontextlost", fnRun);
+  NS_DispatchToCurrentThread(std::move(runnable));
+}
+
+void ClientWebGLContext::Event_webglcontextlost() const {
+  const bool useDefaultHandler = DispatchEvent(u"webglcontextlost"_ns);
+  if (useDefaultHandler) {
+    mLossStatus = webgl::LossStatus::LostForever;
+  }
+
+  if (mLossStatus == webgl::LossStatus::Lost) {
+    RestoreContext(webgl::LossStatus::Lost);
+  }
+}
+
+void ClientWebGLContext::RestoreContext(
+    const webgl::LossStatus requiredStatus) const {
+  if (requiredStatus != mLossStatus) {
+    JsWarning(
+        "restoreContext: Only valid iff context lost with loseContext().");
+    if (!mNextError) {
+      mNextError = LOCAL_GL_INVALID_OPERATION;
+    }
+    return;
+  }
+  MOZ_RELEASE_ASSERT(mLossStatus == webgl::LossStatus::Lost ||
+                     mLossStatus == webgl::LossStatus::LostManually);
+
+  if (mAwaitingRestore) return;
+  mAwaitingRestore = true;
+
+  const auto weak = WeakPtr<const ClientWebGLContext>(this);
+  const auto fnRun = [weak]() {
+    const auto strong = RefPtr<const ClientWebGLContext>(weak);
+    if (!strong) return;
+    strong->Event_webglcontextrestored();
+  };
+  already_AddRefed<mozilla::CancelableRunnable> runnable =
+      NS_NewCancelableRunnableFunction("enqueue Event_webglcontextrestored",
+                                       fnRun);
+  NS_DispatchToCurrentThread(std::move(runnable));
+}
+
+void ClientWebGLContext::Event_webglcontextrestored() const {
+  mAwaitingRestore = false;
+  mLossStatus = webgl::LossStatus::Ready;
+  mNextError = 0;
+
+  uvec2 requestSize;
+  if (mCanvasElement) {
+    requestSize = {mCanvasElement->Width(), mCanvasElement->Height()};
+  } else if (mOffscreenCanvas) {
+    requestSize = {mOffscreenCanvas->Width(), mOffscreenCanvas->Height()};
+  } else {
+    MOZ_ASSERT_UNREACHABLE("no HTMLCanvasElement or OffscreenCanvas!");
+    return;
+  }
+
+  if (!requestSize.x) {
+    requestSize.x = 1;
+  }
+  if (!requestSize.y) {
+    requestSize.y = 1;
+  }
+
+  const auto mutThis = const_cast<ClientWebGLContext*>(
+      this);  // TODO: Make context loss non-mutable.
+  if (!mutThis->CreateHostContext(requestSize)) {
+    mLossStatus = webgl::LossStatus::LostForever;
+    return;
+  }
+
+  mResetLayer = true;
+
+  (void)DispatchEvent(u"webglcontextrestored"_ns);
+}
+
+// ---------
+
+void ClientWebGLContext::ThrowEvent_WebGLContextCreationError(
+    const std::string& text) const {
+  nsCString msg;
+  msg.AppendPrintf("Failed to create WebGL context: %s", text.c_str());
+  JsWarning(msg.BeginReading());
+
+  RefPtr<dom::EventTarget> target = mCanvasElement;
+  if (!target && mOffscreenCanvas) {
+    target = mOffscreenCanvas;
+  } else if (!target) {
+    return;
+  }
+
+  const auto kEventName = u"webglcontextcreationerror"_ns;
+
+  dom::WebGLContextEventInit eventInit;
+  // eventInit.mCancelable = true; // The spec says this, but it's silly.
+  eventInit.mStatusMessage = NS_ConvertASCIItoUTF16(text.c_str());
+
+  const RefPtr<dom::WebGLContextEvent> event =
+      dom::WebGLContextEvent::Constructor(target, kEventName, eventInit);
+  event->SetTrusted(true);
+
+  target->DispatchEvent(*event);
+}
+
+// -------------------------------------------------------------------------
+// Client-side helper methods.  Dispatch to a Host method.
+// -------------------------------------------------------------------------
+
+// If we are running WebGL in this process then call the HostWebGLContext
+// method directly.  Otherwise, dispatch over IPC.
+template <typename MethodT, typename... Args>
+void ClientWebGLContext::Run_WithDestArgTypes(
+    std::optional<JS::AutoCheckCannotGC>&& noGc, const MethodT method,
+    const size_t id, const Args&... args) const {
+  const auto notLost =
+      mNotLost;  // Hold a strong-ref to prevent LoseContext=>UAF.
+
+  // `AutoCheckCannotGC` must be reset after the GC data is done being used but
+  // *before* the `notLost` destructor runs, since the latter can GC.
+  const auto cleanup = MakeScopeExit([&]() { noGc.reset(); });
+
+  if (IsContextLost()) {
+    return;
+  }
+
+  const auto& inProcess = notLost->inProcess;
+  if (inProcess) {
+    (inProcess.get()->*method)(args...);
+    return;
+  }
+
+  const auto& child = notLost->outOfProcess;
+
+  const auto info = webgl::SerializationInfo(id, args...);
+  const auto maybeDest = child->AllocPendingCmdBytes(info.requiredByteCount,
+                                                     info.alignmentOverhead);
+  if (!maybeDest) {
+    noGc.reset();  // Reset early, as GC data will not be used, but JsWarning
+                   // can GC.
+    JsWarning("Failed to allocate internal command buffer.");
+    OnContextLoss(webgl::ContextLossReason::None);
+    return;
+  }
+  const auto& destBytes = *maybeDest;
+  webgl::Serialize(destBytes, id, args...);
+}
+
+// -
+
+#define RPROC(_METHOD) \
+  decltype(&HostWebGLContext::_METHOD), &HostWebGLContext::_METHOD
+
+// ------------------------- Composition, etc -------------------------
+
+void ClientWebGLContext::OnBeforePaintTransaction() { Present(nullptr); }
+
+void ClientWebGLContext::EndComposition() {
+  // Mark ourselves as no longer invalidated.
+  MarkContextClean();
+}
+
+// -
+
+layers::TextureType ClientWebGLContext::GetTexTypeForSwapChain() const {
+  const RefPtr<layers::ImageBridgeChild> imageBridge =
+      layers::ImageBridgeChild::GetSingleton();
+  return layers::TexTypeForWebgl(imageBridge);
+}
+
+void ClientWebGLContext::Present(WebGLFramebufferJS* const xrFb,
+                                 const bool webvr,
+                                 const webgl::SwapChainOptions& options) {
+  const auto texType = GetTexTypeForSwapChain();
+  Present(xrFb, texType, webvr, options);
+}
+
+// Fill in remote texture ids to SwapChainOptions if async present is enabled.
+webgl::SwapChainOptions ClientWebGLContext::PrepareAsyncSwapChainOptions(
+    WebGLFramebufferJS* fb, bool webvr,
+    const webgl::SwapChainOptions& options) {
+  // Currently remote texture ids should only be set internally.
+  MOZ_ASSERT(!options.remoteTextureOwnerId.IsValid() &&
+             !options.remoteTextureId.IsValid());
+  // Async present only works when out-of-process. It is not supported in WebVR.
+  // Allow it if it is either forced or if the pref is set.
+  if (fb || webvr) {
+    return options;
+  }
+  if (!IsContextLost() && !mNotLost->inProcess &&
+      (options.forceAsyncPresent ||
+       StaticPrefs::webgl_out_of_process_async_present())) {
+    if (!mRemoteTextureOwnerId) {
+      mRemoteTextureOwnerId = Some(layers::RemoteTextureOwnerId::GetNext());
+    }
+    mLastRemoteTextureId = Some(layers::RemoteTextureId::GetNext());
+    webgl::SwapChainOptions asyncOptions = options;
+    asyncOptions.remoteTextureOwnerId = *mRemoteTextureOwnerId;
+    asyncOptions.remoteTextureId = *mLastRemoteTextureId;
+    return asyncOptions;
+  }
+  // Clear the current remote texture id so that we disable async.
+  mRemoteTextureOwnerId = Nothing();
+  return options;
+}
+
+void ClientWebGLContext::Present(WebGLFramebufferJS* const xrFb,
+                                 const layers::TextureType type,
+                                 const bool webvr,
+                                 const webgl::SwapChainOptions& options) {
+  if (!mIsCanvasDirty && !xrFb) return;
+  if (!xrFb) {
+    mIsCanvasDirty = false;
+  }
+  CancelAutoFlush();
+  webgl::SwapChainOptions asyncOptions =
+      PrepareAsyncSwapChainOptions(xrFb, webvr, options);
+  Run<RPROC(Present)>(xrFb ? xrFb->mId : 0, type, webvr, asyncOptions);
+}
+
+void ClientWebGLContext::CopyToSwapChain(
+    WebGLFramebufferJS* const fb, const webgl::SwapChainOptions& options) {
+  CancelAutoFlush();
+  const auto texType = GetTexTypeForSwapChain();
+  webgl::SwapChainOptions asyncOptions =
+      PrepareAsyncSwapChainOptions(fb, false, options);
+  Run<RPROC(CopyToSwapChain)>(fb ? fb->mId : 0, texType, asyncOptions);
+}
+
+void ClientWebGLContext::EndOfFrame() {
+  CancelAutoFlush();
+  Run<RPROC(EndOfFrame)>();
+}
+
+Maybe<layers::SurfaceDescriptor> ClientWebGLContext::GetFrontBuffer(
+    WebGLFramebufferJS* const fb, bool vr) {
+  const FuncScope funcScope(*this, "<GetFrontBuffer>");
+  if (IsContextLost()) return {};
+
+  const auto& inProcess = mNotLost->inProcess;
+  if (inProcess) {
+    return inProcess->GetFrontBuffer(fb ? fb->mId : 0, vr);
+  }
+
+  const auto& child = mNotLost->outOfProcess;
+  child->FlushPendingCmds();
+
+  Maybe<layers::SurfaceDescriptor> ret;
+  auto& info = child->GetFlushedCmdInfo();
+
+  // If valid remote texture data was set for async present, then use it.
+  if (!fb && !vr && mRemoteTextureOwnerId && mLastRemoteTextureId) {
+    const auto tooManyFlushes = 10;
+    // If there are many flushed cmds, force synchronous IPC to avoid too many
+    // pending ipc messages.
+    if (XRE_IsParentProcess() ||
+        gfx::gfxVars::WebglOopAsyncPresentForceSync() ||
+        info.flushesSinceLastCongestionCheck > tooManyFlushes) {
+      // Request the front buffer from IPDL to cause a sync, even though we
+      // will continue to use the remote texture descriptor after.
+      (void)child->SendGetFrontBuffer(fb ? fb->mId : 0, vr, &ret);
+    }
+    // Reset flushesSinceLastCongestionCheck
+    info.flushesSinceLastCongestionCheck = 0;
+    info.congestionCheckGeneration++;
+
+    return Some(layers::SurfaceDescriptorRemoteTexture(*mLastRemoteTextureId,
+                                                       *mRemoteTextureOwnerId));
+  }
+
+  if (!child->SendGetFrontBuffer(fb ? fb->mId : 0, vr, &ret)) return {};
+
+  // Reset flushesSinceLastCongestionCheck
+  info.flushesSinceLastCongestionCheck = 0;
+  info.congestionCheckGeneration++;
+
+  return ret;
+}
+
+Maybe<layers::SurfaceDescriptor> ClientWebGLContext::PresentFrontBuffer(
+    WebGLFramebufferJS* const fb, const layers::TextureType type, bool webvr) {
+  Present(fb, type, webvr);
+  return GetFrontBuffer(fb, webvr);
+}
+
+already_AddRefed<layers::FwdTransactionTracker>
+ClientWebGLContext::UseCompositableForwarder(
+    layers::CompositableForwarder* aForwarder) {
+  if (mRemoteTextureOwnerId) {
+    return layers::FwdTransactionTracker::GetOrCreate(mFwdTransactionTracker);
+  }
+  return nullptr;
+}
+
+void ClientWebGLContext::OnDestroyChild(dom::WebGLChild* aChild) {
+  // Since NotLostData may be destructing at this point, the RefPtr to
+  // WebGLChild may be unreliable. Instead, it must be explicitly passed in.
+  if (mRemoteTextureOwnerId && mFwdTransactionTracker &&
+      mFwdTransactionTracker->IsUsed()) {
+    (void)aChild->SendWaitForTxn(
+        *mRemoteTextureOwnerId,
+        layers::ToRemoteTextureTxnType(mFwdTransactionTracker),
+        layers::ToRemoteTextureTxnId(mFwdTransactionTracker));
+  }
+}
+
+void ClientWebGLContext::ClearVRSwapChain() { Run<RPROC(ClearVRSwapChain)>(); }
+
+// -
+
+bool ClientWebGLContext::UpdateWebRenderCanvasData(
+    nsDisplayListBuilder* aBuilder, WebRenderCanvasData* aCanvasData) {
+  CanvasRenderer* renderer = aCanvasData->GetCanvasRenderer();
+
+  if (!IsContextLost() && !mResetLayer && renderer) {
+    return true;
+  }
+
+  const auto& size = DrawingBufferSize();
+
+  if (!IsContextLost() && !renderer && mNotLost->mCanvasRenderer &&
+      mNotLost->mCanvasRenderer->GetSize() == gfx::IntSize(size.x, size.y) &&
+      aCanvasData->SetCanvasRenderer(mNotLost->mCanvasRenderer)) {
+    mNotLost->mCanvasRenderer->SetDirty();
+    mResetLayer = false;
+    return true;
+  }
+
+  renderer = aCanvasData->CreateCanvasRenderer();
+  if (!InitializeCanvasRenderer(aBuilder, renderer)) {
+    // Clear CanvasRenderer of WebRenderCanvasData
+    aCanvasData->ClearCanvasRenderer();
+    return false;
+  }
+
+  mNotLost->mCanvasRenderer = renderer;
+
+  MOZ_ASSERT(renderer);
+  mResetLayer = false;
+
+  return true;
+}
+
+bool ClientWebGLContext::InitializeCanvasRenderer(
+    nsDisplayListBuilder* aBuilder, CanvasRenderer* aRenderer) {
+  const FuncScope funcScope(*this, "<InitializeCanvasRenderer>");
+  if (IsContextLost()) return false;
+
+  layers::CanvasRendererData data;
+  data.mContext = this;
+  data.mOriginPos = gl::OriginPos::BottomLeft;
+
+  const auto& options = *mInitialOptions;
+  const auto& size = DrawingBufferSize();
+
+  if (IsContextLost()) return false;
+
+  data.mIsOpaque = !options.alpha;
+  data.mIsAlphaPremult = !options.alpha || options.premultipliedAlpha;
+  data.mSize = {size.x, size.y};
+
+  if (aBuilder->IsPaintingToWindow() && mCanvasElement) {
+    data.mDoPaintCallbacks = true;
+  }
+
+  aRenderer->Initialize(data);
+  aRenderer->SetDirty();
+  return true;
+}
+
+void ClientWebGLContext::UpdateCanvasParameters() {
+  if (!mOffscreenCanvas) {
+    return;
+  }
+
+  const auto& options = *mInitialOptions;
+  const auto& size = DrawingBufferSize();
+
+  mozilla::dom::OffscreenCanvasDisplayData data;
+  data.mOriginPos = gl::OriginPos::BottomLeft;
+  data.mIsOpaque = !options.alpha;
+  data.mIsAlphaPremult = !options.alpha || options.premultipliedAlpha;
+  data.mSize = {size.x, size.y};
+  data.mDoPaintCallbacks = false;
+
+  mOffscreenCanvas->UpdateDisplayData(data);
+}
+
+layers::LayersBackend ClientWebGLContext::GetCompositorBackendType() const {
+  if (mCanvasElement) {
+    return mCanvasElement->GetCompositorBackendType();
+  } else if (mOffscreenCanvas) {
+    return mOffscreenCanvas->GetCompositorBackendType();
+  }
+
+  return layers::LayersBackend::LAYERS_NONE;
+}
+
+mozilla::dom::Document* ClientWebGLContext::GetOwnerDoc() const {
+  MOZ_ASSERT(mCanvasElement);
+  if (!mCanvasElement) {
+    return nullptr;
+  }
+  return mCanvasElement->OwnerDoc();
+}
+
+void ClientWebGLContext::Commit() {
+  if (mOffscreenCanvas) {
+    mOffscreenCanvas->CommitFrameToCompositor();
+  }
+}
+
+void ClientWebGLContext::GetCanvas(
+    dom::Nullable<dom::OwningHTMLCanvasElementOrOffscreenCanvas>& retval) {
+  if (mCanvasElement) {
+    MOZ_RELEASE_ASSERT(!mOffscreenCanvas, "GFX: Canvas is offscreen.");
+
+    if (mCanvasElement->IsInNativeAnonymousSubtree()) {
+      retval.SetNull();
+    } else {
+      retval.SetValue().SetAsHTMLCanvasElement() = mCanvasElement;
+    }
+  } else if (mOffscreenCanvas) {
+    retval.SetValue().SetAsOffscreenCanvas() = mOffscreenCanvas;
+  } else {
+    retval.SetNull();
+  }
+}
+
+void ClientWebGLContext::GetContextAttributes(
+    dom::Nullable<dom::WebGLContextAttributes>& retval) {
+  retval.SetNull();
+  const FuncScope funcScope(*this, "getContextAttributes");
+  if (IsContextLost()) return;
+
+  dom::WebGLContextAttributes& result = retval.SetValue();
+
+  const auto& options = mNotLost->info.options;
+
+  result.mAlpha.Construct(options.alpha);
+  result.mDepth = options.depth;
+  result.mStencil = options.stencil;
+  result.mAntialias.Construct(options.antialias);
+  result.mPremultipliedAlpha = options.premultipliedAlpha;
+  result.mPreserveDrawingBuffer = options.preserveDrawingBuffer;
+  result.mFailIfMajorPerformanceCaveat = options.failIfMajorPerformanceCaveat;
+  result.mPowerPreference = options.powerPreference;
+}
+
+// -----------------------
+
+NS_IMETHODIMP
+ClientWebGLContext::SetDimensions(const int32_t signedWidth,
+                                  const int32_t signedHeight) {
+  const FuncScope funcScope(*this, "<SetDimensions>");
+  MOZ_ASSERT(mInitialOptions);
+
+  if (mLossStatus != webgl::LossStatus::Ready) {
+    // Attempted resize of a lost context.
+    return NS_OK;
+  }
+
+  uvec2 size = {static_cast<uint32_t>(signedWidth),
+                static_cast<uint32_t>(signedHeight)};
+  if (!size.x) {
+    size.x = 1;
+  }
+  if (!size.y) {
+    size.y = 1;
+  }
+  const auto prevRequestedSize = mRequestedSize;
+  mRequestedSize = size;
+
+  mResetLayer = true;  // Always treat this as resize.
+
+  if (mNotLost) {
+    auto& state = State();
+
+    auto curSize = prevRequestedSize;
+    if (state.mDrawingBufferSize) {
+      curSize = *state.mDrawingBufferSize;
+    }
+    if (size == curSize) return NS_OK;  // MUST skip no-op resize
+
+    state.mDrawingBufferSize = Nothing();
+    Run<RPROC(Resize)>(size);
+
+    UpdateCanvasParameters();
+    MarkCanvasDirty();
+    return NS_OK;
+  }
+
+  // -
+  // Context (re-)creation
+
+  if (!CreateHostContext(size)) {
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+void ClientWebGLContext::ResetBitmap() {
+  const auto size = DrawingBufferSize();
+  Run<RPROC(Resize)>(size);  // No-change resize still clears/resets everything.
+}
+
+static bool IsWebglOutOfProcessEnabled() {
+  if (StaticPrefs::webgl_out_of_process_force()) {
+    return true;
+  }
+  if (!gfx::gfxVars::AllowWebglOop()) {
+    return false;
+  }
+  if (!NS_IsMainThread()) {
+    return StaticPrefs::webgl_out_of_process_worker();
+  }
+  return StaticPrefs::webgl_out_of_process();
+}
+
+bool ClientWebGLContext::CreateHostContext(const uvec2& requestedSize) {
+  const auto pNotLost = std::make_shared<webgl::NotLostData>(*this);
+  auto& notLost = *pNotLost;
+
+  auto res = [&]() -> Result<Ok, std::string> {
+    auto options = *mInitialOptions;
+    if (StaticPrefs::webgl_disable_fail_if_major_performance_caveat()) {
+      options.failIfMajorPerformanceCaveat = false;
+    }
+
+    if (options.failIfMajorPerformanceCaveat) {
+      const auto backend = GetCompositorBackendType();
+      bool isCompositorSlow = false;
+      isCompositorSlow |= (backend == layers::LayersBackend::LAYERS_WR &&
+                           gfx::gfxVars::UseSoftwareWebRender());
+
+      if (isCompositorSlow) {
+        return Err(
+            "failIfMajorPerformanceCaveat: Compositor is not"
+            " hardware-accelerated.");
+      }
+    }
+
+    const bool resistFingerprinting =
+        ShouldResistFingerprinting(RFPTarget::WebGLRenderCapability);
+    const auto principalKey = GetPrincipalHashValue();
+    const auto initDesc = webgl::InitContextDesc{
+        mIsWebGL2, resistFingerprinting, requestedSize, options, principalKey};
+
+    // -
+
+    auto useOop = IsWebglOutOfProcessEnabled();
+    if (XRE_IsParentProcess()) {
+      useOop = false;
+    }
+
+    if (!useOop) {
+      notLost.inProcess =
+          HostWebGLContext::Create({this, nullptr}, initDesc, &notLost.info);
+      return Ok();
+    }
+
+    // -
+
+    ScopedGfxFeatureReporter reporter("IpcWebGL");
+
+    auto* const cm = gfx::CanvasManagerChild::Get();
+    if (NS_WARN_IF(!cm)) {
+      return Err("!CanvasManagerChild::Get()");
+    }
+
+    RefPtr<dom::WebGLChild> outOfProcess = new dom::WebGLChild(*this);
+    outOfProcess =
+        static_cast<dom::WebGLChild*>(cm->SendPWebGLConstructor(outOfProcess));
+    if (!outOfProcess) {
+      return Err("SendPWebGLConstructor failed");
+    }
+
+    // Clear RemoteTextureOwnerId. HostWebGLContext is going to be replaced in
+    // WebGLParent.
+    if (mRemoteTextureOwnerId.isSome()) {
+      mRemoteTextureOwnerId = Nothing();
+      mFwdTransactionTracker = nullptr;
+    }
+
+    if (!outOfProcess->SendInitialize(initDesc, &notLost.info)) {
+      return Err("WebGL actor Initialize failed");
+    }
+
+    notLost.outOfProcess = outOfProcess;
+    reporter.SetSuccessful();
+    return Ok();
+  }();
+  if (!res.isOk()) {
+    auto str = res.unwrapErr();
+    if (StartsWith(str, "failIfMajorPerformanceCaveat")) {
+      str +=
+          " (about:config override available:"
+          " webgl.disable-fail-if-major-performance-caveat)";
+    }
+    notLost.info.error = str;
+  }
+  if (!notLost.info.error->empty()) {
+    ThrowEvent_WebGLContextCreationError(notLost.info.error);
+    return false;
+  }
+  mNotLost = pNotLost;
+  UpdateCanvasParameters();
+  MarkCanvasDirty();
+
+  // Init state
+  const auto& limits = Limits();
+  auto& state = State();
+  state.mDefaultTfo = new WebGLTransformFeedbackJS(*this);
+  state.mDefaultVao = new WebGLVertexArrayJS(*this);
+
+  state.mBoundTfo = state.mDefaultTfo;
+  state.mBoundVao = state.mDefaultVao;
+
+  (void)state.mBoundBufferByTarget[LOCAL_GL_ARRAY_BUFFER];
+
+  state.mTexUnits.resize(limits.maxTexUnits);
+  state.mBoundUbos.resize(limits.maxUniformBufferBindings);
+
+  {
+    webgl::TypedQuad initVal;
+    const float fData[4] = {0, 0, 0, 1};
+    memcpy(initVal.data.data(), fData, initVal.data.size());
+    state.mGenericVertexAttribs.resize(limits.maxVertexAttribs, initVal);
+  }
+
+  const auto& size = DrawingBufferSize();
+  state.mViewport = {0, 0, static_cast<int32_t>(size.x),
+                     static_cast<int32_t>(size.y)};
+  state.mScissor = state.mViewport;
+
+  if (mIsWebGL2) {
+    // Insert keys to enable slots:
+    (void)state.mBoundBufferByTarget[LOCAL_GL_COPY_READ_BUFFER];
+    (void)state.mBoundBufferByTarget[LOCAL_GL_COPY_WRITE_BUFFER];
+    (void)state.mBoundBufferByTarget[LOCAL_GL_PIXEL_PACK_BUFFER];
+    (void)state.mBoundBufferByTarget[LOCAL_GL_PIXEL_UNPACK_BUFFER];
+    (void)state.mBoundBufferByTarget[LOCAL_GL_TRANSFORM_FEEDBACK_BUFFER];
+    (void)state.mBoundBufferByTarget[LOCAL_GL_UNIFORM_BUFFER];
+
+    (void)state.mCurrentQueryByTarget[LOCAL_GL_ANY_SAMPLES_PASSED];
+    //(void)state.mCurrentQueryByTarget[LOCAL_GL_ANY_SAMPLES_PASSED_CONSERVATIVE];
+    //// Same slot as ANY_SAMPLES_PASSED.
+    (void)state
+        .mCurrentQueryByTarget[LOCAL_GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN];
+  }
+
+  return true;
+}
+
+// -------
+
+uvec2 ClientWebGLContext::DrawingBufferSize() {
+  if (IsContextLost()) return {};
+  const auto notLost =
+      mNotLost;  // Hold a strong-ref to prevent LoseContext=>UAF.
+  auto& state = State();
+  auto& size = state.mDrawingBufferSize;
+
+  if (!size) {
+    const auto& inProcess = mNotLost->inProcess;
+    if (inProcess) {
+      size = Some(inProcess->DrawingBufferSize());
+    } else {
+      const auto& child = mNotLost->outOfProcess;
+      child->FlushPendingCmds();
+      uvec2 actual = {};
+      if (!child->SendDrawingBufferSize(&actual)) return {};
+      size = Some(actual);
+    }
+  }
+
+  return *size;
+}
+
+void ClientWebGLContext::OnMemoryPressure() {
+  if (IsContextLost()) return;
+
+  const auto& inProcess = mNotLost->inProcess;
+  if (inProcess) {
+    return inProcess->OnMemoryPressure();
+  }
+  const auto& child = mNotLost->outOfProcess;
+  (void)child->SendOnMemoryPressure();
+}
+
+NS_IMETHODIMP
+ClientWebGLContext::SetContextOptions(JSContext* cx,
+                                      JS::Handle<JS::Value> options,
+                                      ErrorResult& aRvForDictionaryInit) {
+  if (mInitialOptions && options.isNullOrUndefined()) return NS_OK;
+
+  dom::WebGLContextAttributes attributes;
+  if (!attributes.Init(cx, options)) {
+    aRvForDictionaryInit.Throw(NS_ERROR_UNEXPECTED);
+    return NS_ERROR_UNEXPECTED;
+  }
+
+  WebGLContextOptions newOpts;
+
+  newOpts.stencil = attributes.mStencil;
+  newOpts.depth = attributes.mDepth;
+  newOpts.premultipliedAlpha = attributes.mPremultipliedAlpha;
+  newOpts.preserveDrawingBuffer = attributes.mPreserveDrawingBuffer;
+  newOpts.failIfMajorPerformanceCaveat =
+      attributes.mFailIfMajorPerformanceCaveat;
+  newOpts.xrCompatible = attributes.mXrCompatible;
+  newOpts.powerPreference = attributes.mPowerPreference;
+  newOpts.enableDebugRendererInfo =
+      StaticPrefs::webgl_enable_debug_renderer_info();
+  MOZ_ASSERT(mCanvasElement || mOffscreenCanvas);
+  newOpts.shouldResistFingerprinting =
+      ShouldResistFingerprinting(RFPTarget::WebGLRenderCapability);
+
+  if (attributes.mAlpha.WasPassed()) {
+    newOpts.alpha = attributes.mAlpha.Value();
+  }
+  if (attributes.mAntialias.WasPassed()) {
+    newOpts.antialias = attributes.mAntialias.Value();
+  }
+  newOpts.ignoreColorSpace = true;
+  if (attributes.mColorSpace.WasPassed()) {
+    newOpts.ignoreColorSpace = false;
+    newOpts.colorSpace = attributes.mColorSpace.Value();
+  }
+
+  // Don't do antialiasing if we've disabled MSAA.
+  if (!StaticPrefs::webgl_msaa_samples()) {
+    newOpts.antialias = false;
+  }
+
+  // -
+
+  if (mInitialOptions && *mInitialOptions != newOpts) {
+    // Err if the options asked for aren't the same as what they were
+    // originally.
+    return NS_ERROR_FAILURE;
+  }
+
+  mXRCompatible = attributes.mXrCompatible;
+
+  mInitialOptions.emplace(newOpts);
+  return NS_OK;
+}
+
+void ClientWebGLContext::DidRefresh() { Run<RPROC(DidRefresh)>(); }
+
+already_AddRefed<gfx::SourceSurface> ClientWebGLContext::GetSurfaceSnapshot(
+    gfxAlphaType* const out_alphaType) {
+  const FuncScope funcScope(*this, "<GetSurfaceSnapshot>");
+  if (IsContextLost()) return nullptr;
+  const auto notLost =
+      mNotLost;  // Hold a strong-ref to prevent LoseContext=>UAF.
+
+  auto ret = BackBufferSnapshot();
+  if (!ret) return nullptr;
+
+  // -
+
+  const auto& options = mNotLost->info.options;
+
+  auto srcAlphaType = gfxAlphaType::Opaque;
+  if (options.alpha) {
+    if (options.premultipliedAlpha) {
+      srcAlphaType = gfxAlphaType::Premult;
+    } else {
+      srcAlphaType = gfxAlphaType::NonPremult;
+    }
+  }
+
+  if (out_alphaType) {
+    *out_alphaType = srcAlphaType;
+  } else {
+    // Expects Opaque or Premult
+    if (srcAlphaType == gfxAlphaType::NonPremult) {
+      const gfx::DataSourceSurface::ScopedMap map(
+          ret, gfx::DataSourceSurface::READ_WRITE);
+      MOZ_RELEASE_ASSERT(map.IsMapped(), "Failed to map snapshot surface!");
+
+      const auto& size = ret->GetSize();
+      const auto format = ret->GetFormat();
+      bool rv =
+          gfx::PremultiplyData(map.GetData(), map.GetStride(), format,
+                               map.GetData(), map.GetStride(), format, size);
+      MOZ_RELEASE_ASSERT(rv, "PremultiplyData failed!");
+    }
+  }
+
+  return ret.forget();
+}
+
+RefPtr<gfx::SourceSurface> ClientWebGLContext::GetFrontBufferSnapshot(
+    const bool requireAlphaPremult) {
+  const FuncScope funcScope(*this, "<GetSurfaceSnapshot>");
+  if (IsContextLost()) return nullptr;
+  const auto notLost =
+      mNotLost;  // Hold a strong-ref to prevent LoseContext=>UAF.
+
+  const auto& options = mNotLost->info.options;
+
+  const auto surfFormat = options.alpha ? gfx::SurfaceFormat::B8G8R8A8
+                                        : gfx::SurfaceFormat::B8G8R8X8;
+
+  const auto fnNewSurf = [&](const uvec2 size) {
+    const auto stride = size.x * 4;
+    return RefPtr<gfx::DataSourceSurface>(
+        gfx::Factory::CreateDataSourceSurfaceWithStride({size.x, size.y},
+                                                        surfFormat, stride,
+                                                        /*zero=*/true));
+  };
+
+  const auto& inProcess = mNotLost->inProcess;
+  if (inProcess) {
+    const auto maybeSize = inProcess->FrontBufferSnapshotInto({});
+    if (!maybeSize) return nullptr;
+    const auto& surfSize = *maybeSize;
+    const auto stride = surfSize.x * 4;
+    const auto byteSize = stride * surfSize.y;
+    const auto surf = fnNewSurf(surfSize);
+    if (!surf) return nullptr;
+    {
+      const gfx::DataSourceSurface::ScopedMap map(
+          surf, gfx::DataSourceSurface::READ_WRITE);
+      if (!map.IsMapped()) {
+        MOZ_ASSERT(false);
+        return nullptr;
+      }
+      MOZ_RELEASE_ASSERT(map.GetStride() == static_cast<int64_t>(stride));
+      auto range = Range<uint8_t>{map.GetData(), byteSize};
+      if (!inProcess->FrontBufferSnapshotInto(Some(range))) {
+        gfxCriticalNote << "ClientWebGLContext::GetFrontBufferSnapshot: "
+                           "FrontBufferSnapshotInto(some) failed after "
+                           "FrontBufferSnapshotInto(none)";
+        return nullptr;
+      }
+      if (requireAlphaPremult && options.alpha && !options.premultipliedAlpha) {
+        bool rv = gfx::PremultiplyData(
+            map.GetData(), map.GetStride(), gfx::SurfaceFormat::R8G8B8A8,
+            map.GetData(), map.GetStride(), gfx::SurfaceFormat::B8G8R8A8,
+            surf->GetSize());
+        MOZ_RELEASE_ASSERT(rv, "PremultiplyData failed!");
+      } else {
+        bool rv = gfx::SwizzleData(
+            map.GetData(), map.GetStride(), gfx::SurfaceFormat::R8G8B8A8,
+            map.GetData(), map.GetStride(), gfx::SurfaceFormat::B8G8R8A8,
+            surf->GetSize());
+        MOZ_RELEASE_ASSERT(rv, "SwizzleData failed!");
+      }
+    }
+    return surf;
+  }
+  const auto& child = mNotLost->outOfProcess;
+  child->FlushPendingCmds();
+  webgl::FrontBufferSnapshotIpc res;
+  if (!child->SendGetFrontBufferSnapshot(&res)) {
+    res = {};
+  }
+  if (!res.shmem) return nullptr;
+
+  const auto& surfSize = res.surfSize;
+  const webgl::RaiiShmem shmem{child, res.shmem.ref()};
+  if (!shmem) return nullptr;
+  const auto& shmemBytes = shmem.ByteRange();
+  if (!surfSize.x) return nullptr;  // Zero means failure.
+
+  const auto stride = surfSize.x * 4;
+  const auto byteSize = stride * surfSize.y;
+
+  const auto surf = fnNewSurf(surfSize);
+  if (!surf) return nullptr;
+
+  {
+    const gfx::DataSourceSurface::ScopedMap map(
+        surf, gfx::DataSourceSurface::READ_WRITE);
+    if (!map.IsMapped()) {
+      MOZ_ASSERT(false);
+      return nullptr;
+    }
+    MOZ_RELEASE_ASSERT(shmemBytes.length() == byteSize);
+    if (requireAlphaPremult && options.alpha && !options.premultipliedAlpha) {
+      bool rv = gfx::PremultiplyData(
+          shmemBytes.begin().get(), stride, gfx::SurfaceFormat::R8G8B8A8,
+          map.GetData(), map.GetStride(), gfx::SurfaceFormat::B8G8R8A8,
+          surf->GetSize());
+      MOZ_RELEASE_ASSERT(rv, "PremultiplyData failed!");
+    } else {
+      bool rv = gfx::SwizzleData(shmemBytes.begin().get(), stride,
+                                 gfx::SurfaceFormat::R8G8B8A8, map.GetData(),
+                                 map.GetStride(), gfx::SurfaceFormat::B8G8R8A8,
+                                 surf->GetSize());
+      MOZ_RELEASE_ASSERT(rv, "SwizzleData failed!");
+    }
+  }
+  return surf;
+}
+
+RefPtr<gfx::DataSourceSurface> ClientWebGLContext::BackBufferSnapshot() {
+  if (IsContextLost()) return nullptr;
+  const auto notLost =
+      mNotLost;  // Hold a strong-ref to prevent LoseContext=>UAF.
+
+  const auto& options = mNotLost->info.options;
+  const auto& state = State();
+
+  const auto drawFbWas = state.mBoundDrawFb;
+  const auto readFbWas = state.mBoundReadFb;
+  const auto pboWas =
+      Find(state.mBoundBufferByTarget, LOCAL_GL_PIXEL_PACK_BUFFER);
+
+  const auto size = DrawingBufferSize();
+
+  // -
+
+  BindFramebuffer(LOCAL_GL_FRAMEBUFFER, nullptr);
+  if (pboWas) {
+    BindBuffer(LOCAL_GL_PIXEL_PACK_BUFFER, nullptr);
+  }
+
+  auto reset = MakeScopeExit([&] {
+    if (drawFbWas == readFbWas) {
+      BindFramebuffer(LOCAL_GL_FRAMEBUFFER, drawFbWas);
+    } else {
+      BindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER, drawFbWas);
+      BindFramebuffer(LOCAL_GL_READ_FRAMEBUFFER, readFbWas);
+    }
+    if (pboWas) {
+      BindBuffer(LOCAL_GL_PIXEL_PACK_BUFFER, pboWas);
+    }
+  });
+
+  const auto surfFormat = options.alpha ? gfx::SurfaceFormat::B8G8R8A8
+                                        : gfx::SurfaceFormat::B8G8R8X8;
+  const auto stride = size.x * 4;
+  RefPtr<gfx::DataSourceSurface> surf =
+      gfx::Factory::CreateDataSourceSurfaceWithStride(
+          {size.x, size.y}, surfFormat, stride, /*zero=*/true);
+  if (NS_WARN_IF(!surf)) {
+    // Was this an OOM or alloc-limit? (500MB is our default resource size
+    // limit)
+    surf = gfx::Factory::CreateDataSourceSurfaceWithStride({1, 1}, surfFormat,
+                                                           4, /*zero=*/true);
+    if (!surf) {
+      // Still failed for a 1x1 size.
+      gfxCriticalError() << "CreateDataSourceSurfaceWithStride(surfFormat="
+                         << surfFormat << ") failed.";
+    }
+    return nullptr;
+  }
+
+  {
+    const gfx::DataSourceSurface::ScopedMap map(
+        surf, gfx::DataSourceSurface::READ_WRITE);
+    if (!map.IsMapped()) {
+      MOZ_ASSERT(false);
+      return nullptr;
+    }
+    MOZ_ASSERT(static_cast<uint32_t>(map.GetStride()) == stride);
+
+    const auto desc = webgl::ReadPixelsDesc{{0, 0}, size};
+    const auto range = Range<uint8_t>(map.GetData(), stride * size.y);
+    if (!DoReadPixels(desc, range)) return nullptr;
+
+    const auto begin = range.begin().get();
+
+    std::vector<uint8_t> temp;
+    temp.resize(stride);
+    for (const auto i : IntegerRange(size.y / 2)) {
+      const auto top = begin + stride * i;
+      const auto bottom = begin + stride * (size.y - 1 - i);
+      memcpy(temp.data(), top, stride);
+      memcpy(top, bottom, stride);
+      gfxUtils::ConvertBGRAtoRGBA(top, stride);
+
+      memcpy(bottom, temp.data(), stride);
+      gfxUtils::ConvertBGRAtoRGBA(bottom, stride);
+    }
+
+    if (size.y % 2) {
+      const auto middle = begin + stride * (size.y / 2);
+      gfxUtils::ConvertBGRAtoRGBA(middle, stride);
+    }
+  }
+
+  return surf;
+}
+
+UniquePtr<uint8_t[]> ClientWebGLContext::GetImageBuffer(
+    int32_t* out_format, gfx::IntSize* out_imageSize) {
+  *out_format = 0;
+  *out_imageSize = {};
+
+  // Use GetSurfaceSnapshot() to make sure that appropriate y-flip gets applied
+  gfxAlphaType any;
+  RefPtr<gfx::SourceSurface> snapshot = GetSurfaceSnapshot(&any);
+  if (!snapshot) return nullptr;
+
+  RefPtr<gfx::DataSourceSurface> dataSurface = snapshot->GetDataSurface();
+
+  const auto& premultAlpha = mNotLost->info.options.premultipliedAlpha;
+  *out_imageSize = dataSurface->GetSize();
+
+  if (ShouldResistFingerprinting(RFPTarget::CanvasRandomization)) {
+    return gfxUtils::GetImageBufferWithRandomNoise(
+        dataSurface, premultAlpha, GetCookieJarSettings(), out_format);
+  }
+
+  return gfxUtils::GetImageBuffer(dataSurface, premultAlpha, out_format);
+}
+
+NS_IMETHODIMP
+ClientWebGLContext::GetInputStream(const char* mimeType,
+                                   const nsAString& encoderOptions,
+                                   nsIInputStream** out_stream) {
+  // Use GetSurfaceSnapshot() to make sure that appropriate y-flip gets applied
+  gfxAlphaType any;
+  RefPtr<gfx::SourceSurface> snapshot = GetSurfaceSnapshot(&any);
+  if (!snapshot) return NS_ERROR_FAILURE;
+
+  RefPtr<gfx::DataSourceSurface> dataSurface = snapshot->GetDataSurface();
+  const auto& premultAlpha = mNotLost->info.options.premultipliedAlpha;
+
+  if (ShouldResistFingerprinting(RFPTarget::CanvasRandomization)) {
+    return gfxUtils::GetInputStreamWithRandomNoise(
+        dataSurface, premultAlpha, mimeType, encoderOptions,
+        GetCookieJarSettings(), out_stream);
+  }
+
+  return gfxUtils::GetInputStream(dataSurface, premultAlpha, mimeType,
+                                  encoderOptions, out_stream);
+}
+
+// ------------------------- Client WebGL Objects -------------------------
+// ------------------------- Create/Destroy/Is -------------------------
+
+template <typename T>
+static already_AddRefed<T> AsAddRefed(T* ptr) {
+  RefPtr<T> rp = ptr;
+  return rp.forget();
+}
+
+template <typename T>
+static RefPtr<T> AsRefPtr(T* ptr) {
+  return {ptr};
+}
+
+already_AddRefed<WebGLBufferJS> ClientWebGLContext::CreateBuffer() const {
+  const FuncScope funcScope(*this, "createBuffer");
+  if (IsContextLost()) return nullptr;
+
+  auto ret = AsRefPtr(new WebGLBufferJS(*this));
+  Run<RPROC(CreateBuffer)>(ret->mId);
+  return ret.forget();
+}
+
+already_AddRefed<WebGLFramebufferJS> ClientWebGLContext::CreateFramebuffer()
+    const {
+  const FuncScope funcScope(*this, "createFramebuffer");
+  if (IsContextLost()) return nullptr;
+
+  auto ret = AsRefPtr(new WebGLFramebufferJS(*this));
+  Run<RPROC(CreateFramebuffer)>(ret->mId);
+  return ret.forget();
+}
+
+already_AddRefed<WebGLFramebufferJS>
+ClientWebGLContext::CreateOpaqueFramebuffer(
+    const webgl::OpaqueFramebufferOptions& options) const {
+  const FuncScope funcScope(*this, "createOpaqueFramebuffer");
+  if (IsContextLost()) return nullptr;
+
+  auto ret = AsRefPtr(new WebGLFramebufferJS(*this, true));
+
+  const auto& inProcess = mNotLost->inProcess;
+  if (inProcess) {
+    if (!inProcess->CreateOpaqueFramebuffer(ret->mId, options)) {
+      ret = nullptr;
+    }
+    return ret.forget();
+  }
+  const auto& child = mNotLost->outOfProcess;
+  child->FlushPendingCmds();
+  bool ok = false;
+  if (!child->SendCreateOpaqueFramebuffer(ret->mId, options, &ok))
+    return nullptr;
+  if (!ok) return nullptr;
+  return ret.forget();
+}
+
+already_AddRefed<WebGLProgramJS> ClientWebGLContext::CreateProgram() const {
+  const FuncScope funcScope(*this, "createProgram");
+  if (IsContextLost()) return nullptr;
+
+  auto ret = AsRefPtr(new WebGLProgramJS(*this));
+  Run<RPROC(CreateProgram)>(ret->mId);
+  return ret.forget();
+}
+
+already_AddRefed<WebGLQueryJS> ClientWebGLContext::CreateQuery() const {
+  const FuncScope funcScope(*this, "createQuery");
+  if (IsContextLost()) return nullptr;
+
+  auto ret = AsRefPtr(new WebGLQueryJS(*this));
+  Run<RPROC(CreateQuery)>(ret->mId);
+  return ret.forget();
+}
+
+already_AddRefed<WebGLRenderbufferJS> ClientWebGLContext::CreateRenderbuffer()
+    const {
+  const FuncScope funcScope(*this, "createRenderbuffer");
+  if (IsContextLost()) return nullptr;
+
+  auto ret = AsRefPtr(new WebGLRenderbufferJS(*this));
+  Run<RPROC(CreateRenderbuffer)>(ret->mId);
+  return ret.forget();
+}
+
+already_AddRefed<WebGLSamplerJS> ClientWebGLContext::CreateSampler() const {
+  const FuncScope funcScope(*this, "createSampler");
+  if (IsContextLost()) return nullptr;
+
+  auto ret = AsRefPtr(new WebGLSamplerJS(*this));
+  Run<RPROC(CreateSampler)>(ret->mId);
+  return ret.forget();
+}
+
+already_AddRefed<WebGLShaderJS> ClientWebGLContext::CreateShader(
+    const GLenum type) const {
+  const FuncScope funcScope(*this, "createShader");
+  if (IsContextLost()) return nullptr;
+
+  switch (type) {
+    case LOCAL_GL_VERTEX_SHADER:
+    case LOCAL_GL_FRAGMENT_SHADER:
+      break;
+    default:
+      EnqueueError_ArgEnum("type", type);
+      return nullptr;
+  }
+
+  auto ret = AsRefPtr(new WebGLShaderJS(*this, type));
+  Run<RPROC(CreateShader)>(ret->mId, ret->mType);
+  return ret.forget();
+}
+
+already_AddRefed<WebGLSyncJS> ClientWebGLContext::FenceSync(
+    const GLenum condition, const GLbitfield flags) const {
+  const FuncScope funcScope(*this, "fenceSync");
+  if (IsContextLost()) return nullptr;
+
+  if (condition != LOCAL_GL_SYNC_GPU_COMMANDS_COMPLETE) {
+    EnqueueError_ArgEnum("condition", condition);
+    return nullptr;
+  }
+
+  if (flags) {
+    EnqueueError(LOCAL_GL_INVALID_VALUE, "`flags` must be 0.");
+    return nullptr;
+  }
+
+  auto ret = AsRefPtr(new WebGLSyncJS(*this));
+  Run<RPROC(CreateSync)>(ret->mId);
+
+  auto& availRunnable = EnsureAvailabilityRunnable();
+  availRunnable.mSyncs.push_back(ret.get());
+  ret->mCanBeAvailable = false;
+
+  return ret.forget();
+}
+
+already_AddRefed<WebGLTextureJS> ClientWebGLContext::CreateTexture() const {
+  const FuncScope funcScope(*this, "createTexture");
+  if (IsContextLost()) return nullptr;
+
+  auto ret = AsRefPtr(new WebGLTextureJS(*this));
+  Run<RPROC(CreateTexture)>(ret->mId);
+  return ret.forget();
+}
+
+already_AddRefed<WebGLTransformFeedbackJS>
+ClientWebGLContext::CreateTransformFeedback() const {
+  const FuncScope funcScope(*this, "createTransformFeedback");
+  if (IsContextLost()) return nullptr;
+
+  auto ret = AsRefPtr(new WebGLTransformFeedbackJS(*this));
+  Run<RPROC(CreateTransformFeedback)>(ret->mId);
+  return ret.forget();
+}
+
+already_AddRefed<WebGLVertexArrayJS> ClientWebGLContext::CreateVertexArray()
+    const {
+  const FuncScope funcScope(*this, "createVertexArray");
+  if (IsContextLost()) return nullptr;
+
+  auto ret = AsRefPtr(new WebGLVertexArrayJS(*this));
+  Run<RPROC(CreateVertexArray)>(ret->mId);
+  return ret.forget();
+}
+
+// -
+
+static bool ValidateOrSkipForDelete(const ClientWebGLContext& context,
+                                    const webgl::ObjectJS* const obj) {
+  if (!obj) return false;
+  if (!obj->ValidateForContext(context, "obj")) return false;
+  if (obj->IsDeleted()) return false;
+  return true;
+}
+
+void ClientWebGLContext::DeleteBuffer(WebGLBufferJS* const obj) {
+  const FuncScope funcScope(*this, "deleteBuffer");
+  if (IsContextLost()) return;
+  if (!ValidateOrSkipForDelete(*this, obj)) return;
+  auto& state = State();
+
+  // Unbind from all bind points and bound containers
+
+  // UBOs
+  for (const auto i : IntegerRange(state.mBoundUbos.size())) {
+    if (state.mBoundUbos[i] == obj) {
+      BindBufferBase(LOCAL_GL_UNIFORM_BUFFER, i, nullptr);
+    }
+  }
+
+  // TFO only if not active
+  if (!state.mBoundTfo->mActiveOrPaused) {
+    const auto& buffers = state.mBoundTfo->mAttribBuffers;
+    for (const auto i : IntegerRange(buffers.size())) {
+      if (buffers[i] == obj) {
+        BindBufferBase(LOCAL_GL_TRANSFORM_FEEDBACK_BUFFER, i, nullptr);
+      }
+    }
+  }
+
+  // Generic/global bind points
+  for (const auto& pair : state.mBoundBufferByTarget) {
+    if (pair.second == obj) {
+      BindBuffer(pair.first, nullptr);
+    }
+  }
+
+  // VAO attachments
+  if (state.mBoundVao->mIndexBuffer == obj) {
+    BindBuffer(LOCAL_GL_ELEMENT_ARRAY_BUFFER, nullptr);
+  }
+
+  const auto& vaoBuffers = state.mBoundVao->mAttribBuffers;
+  Maybe<WebGLBufferJS*> toRestore;
+  for (const auto i : IntegerRange(vaoBuffers.size())) {
+    if (vaoBuffers[i] == obj) {
+      if (!toRestore) {
+        toRestore =
+            Some(state.mBoundBufferByTarget[LOCAL_GL_ARRAY_BUFFER].get());
+        if (*toRestore) {
+          BindBuffer(LOCAL_GL_ARRAY_BUFFER, nullptr);
+        }
+      }
+      VertexAttribPointer(i, 4, LOCAL_GL_FLOAT, false, 0, 0);
+    }
+  }
+  if (toRestore && *toRestore) {
+    BindBuffer(LOCAL_GL_ARRAY_BUFFER, *toRestore);
+  }
+
+  // -
+
+  obj->mDeleteRequested = true;
+  Run<RPROC(DeleteBuffer)>(obj->mId);
+}
+
+void ClientWebGLContext::DeleteFramebuffer(WebGLFramebufferJS* const obj,
+                                           bool canDeleteOpaque) {
+  const FuncScope funcScope(*this, "deleteFramebuffer");
+  if (IsContextLost()) return;
+  if (!ValidateOrSkipForDelete(*this, obj)) return;
+  if (!canDeleteOpaque && obj->mOpaque) {
+    EnqueueError(
+        LOCAL_GL_INVALID_OPERATION,
+        "An opaque framebuffer's attachments cannot be inspected or changed.");
+    return;
+  }
+  const auto& state = State();
+
+  // Unbind
+  const auto fnDetach = [&](const GLenum target,
+                            const WebGLFramebufferJS* const fb) {
+    if (obj == fb) {
+      BindFramebuffer(target, nullptr);
+    }
+  };
+  if (state.mBoundDrawFb == state.mBoundReadFb) {
+    fnDetach(LOCAL_GL_FRAMEBUFFER, state.mBoundDrawFb.get());
+  } else {
+    fnDetach(LOCAL_GL_DRAW_FRAMEBUFFER, state.mBoundDrawFb.get());
+    fnDetach(LOCAL_GL_READ_FRAMEBUFFER, state.mBoundReadFb.get());
+  }
+
+  obj->mDeleteRequested = true;
+  Run<RPROC(DeleteFramebuffer)>(obj->mId);
+}
+
+void ClientWebGLContext::DeleteProgram(WebGLProgramJS* const obj) const {
+  const FuncScope funcScope(*this, "deleteProgram");
+  if (IsContextLost()) return;
+  if (!ValidateOrSkipForDelete(*this, obj)) return;
+
+  // Don't unbind
+
+  obj->mKeepAlive = nullptr;
+}
+
+webgl::ProgramKeepAlive::~ProgramKeepAlive() {
+  if (!mParent) return;
+  const auto& context = mParent->Context();
+  if (!context) return;
+  context->DoDeleteProgram(*mParent);
+}
+
+void ClientWebGLContext::DoDeleteProgram(WebGLProgramJS& obj) const {
+  obj.mNextLink_Shaders = {};
+  Run<RPROC(DeleteProgram)>(obj.mId);
+}
+
+static GLenum QuerySlotTarget(const GLenum specificTarget);
+
+void ClientWebGLContext::DeleteQuery(WebGLQueryJS* const obj) {
+  const FuncScope funcScope(*this, "deleteQuery");
+  if (IsContextLost()) return;
+  if (!ValidateOrSkipForDelete(*this, obj)) return;
+  const auto& state = State();
+
+  // Unbind if current
+
+  if (obj->mTarget) {
+    // Despite mTarget being set, we may not have called BeginQuery on this
+    // object. QueryCounter may also set mTarget.
+    const auto slotTarget = QuerySlotTarget(obj->mTarget);
+    const auto curForTarget =
+        MaybeFind(state.mCurrentQueryByTarget, slotTarget);
+
+    if (curForTarget && *curForTarget == obj) {
+      EndQuery(obj->mTarget);
+    }
+  }
+
+  obj->mDeleteRequested = true;
+  Run<RPROC(DeleteQuery)>(obj->mId);
+}
+
+void ClientWebGLContext::DeleteRenderbuffer(WebGLRenderbufferJS* const obj) {
+  const FuncScope funcScope(*this, "deleteRenderbuffer");
+  if (IsContextLost()) return;
+  if (!ValidateOrSkipForDelete(*this, obj)) return;
+  const auto& state = State();
+
+  // Unbind
+  if (state.mBoundRb == obj) {
+    BindRenderbuffer(LOCAL_GL_RENDERBUFFER, nullptr);
+  }
+
+  // Unbind from bound FBs
+  const auto fnDetach = [&](const GLenum target,
+                            const WebGLFramebufferJS* const fb) {
+    if (!fb) return;
+    for (const auto& pair : fb->mAttachments) {
+      if (pair.second.rb == obj) {
+        FramebufferRenderbuffer(target, pair.first, LOCAL_GL_RENDERBUFFER,
+                                nullptr);
+      }
+    }
+  };
+  if (state.mBoundDrawFb == state.mBoundReadFb) {
+    fnDetach(LOCAL_GL_FRAMEBUFFER, state.mBoundDrawFb.get());
+  } else {
+    fnDetach(LOCAL_GL_DRAW_FRAMEBUFFER, state.mBoundDrawFb.get());
+    fnDetach(LOCAL_GL_READ_FRAMEBUFFER, state.mBoundReadFb.get());
+  }
+
+  obj->mDeleteRequested = true;
+  Run<RPROC(DeleteRenderbuffer)>(obj->mId);
+}
+
+void ClientWebGLContext::DeleteSampler(WebGLSamplerJS* const obj) {
+  const FuncScope funcScope(*this, "deleteSampler");
+  if (IsContextLost()) return;
+  if (!ValidateOrSkipForDelete(*this, obj)) return;
+  const auto& state = State();
+
+  // Unbind
+  for (const auto i : IntegerRange(state.mTexUnits.size())) {
+    if (state.mTexUnits[i].sampler == obj) {
+      BindSampler(i, nullptr);
+    }
+  }
+
+  obj->mDeleteRequested = true;
+  Run<RPROC(DeleteSampler)>(obj->mId);
+}
+
+void ClientWebGLContext::DeleteShader(WebGLShaderJS* const obj) const {
+  const FuncScope funcScope(*this, "deleteShader");
+  if (IsContextLost()) return;
+  if (!ValidateOrSkipForDelete(*this, obj)) return;
+
+  // Don't unbind
+
+  obj->mKeepAlive = nullptr;
+}
+
+webgl::ShaderKeepAlive::~ShaderKeepAlive() {
+  if (!mParent) return;
+  const auto& context = mParent->Context();
+  if (!context) return;
+  context->DoDeleteShader(*mParent);
+}
+
+void ClientWebGLContext::DoDeleteShader(const WebGLShaderJS& obj) const {
+  Run<RPROC(DeleteShader)>(obj.mId);
+}
+
+void ClientWebGLContext::DeleteSync(WebGLSyncJS* const obj) const {
+  const FuncScope funcScope(*this, "deleteSync");
+  if (IsContextLost()) return;
+  if (!ValidateOrSkipForDelete(*this, obj)) return;
+
+  // Nothing to unbind
+
+  obj->mDeleteRequested = true;
+  Run<RPROC(DeleteSync)>(obj->mId);
+}
+
+void ClientWebGLContext::DeleteTexture(WebGLTextureJS* const obj) {
+  const FuncScope funcScope(*this, "deleteTexture");
+  if (IsContextLost()) return;
+  if (!ValidateOrSkipForDelete(*this, obj)) return;
+  auto& state = State();
+
+  // Unbind
+  const auto& target = obj->mTarget;
+  if (target) {
+    // Unbind from tex units
+    Maybe<uint32_t> restoreTexUnit;
+    for (const auto i : IntegerRange(state.mTexUnits.size())) {
+      if (state.mTexUnits[i].texByTarget[target] == obj) {
+        if (!restoreTexUnit) {
+          restoreTexUnit = Some(state.mActiveTexUnit);
+        }
+        ActiveTexture(LOCAL_GL_TEXTURE0 + i);
+        BindTexture(target, nullptr);
+      }
+    }
+    if (restoreTexUnit) {
+      ActiveTexture(LOCAL_GL_TEXTURE0 + *restoreTexUnit);
+    }
+
+    // Unbind from bound FBs
+    const auto fnDetach = [&](const GLenum target,
+                              const WebGLFramebufferJS* const fb) {
+      if (!fb) return;
+      for (const auto& pair : fb->mAttachments) {
+        if (pair.second.tex == obj) {
+          FramebufferRenderbuffer(target, pair.first, LOCAL_GL_RENDERBUFFER,
+                                  nullptr);
+        }
+      }
+    };
+    if (state.mBoundDrawFb == state.mBoundReadFb) {
+      fnDetach(LOCAL_GL_FRAMEBUFFER, state.mBoundDrawFb.get());
+    } else {
+      fnDetach(LOCAL_GL_DRAW_FRAMEBUFFER, state.mBoundDrawFb.get());
+      fnDetach(LOCAL_GL_READ_FRAMEBUFFER, state.mBoundReadFb.get());
+    }
+  }
+
+  obj->mDeleteRequested = true;
+  Run<RPROC(DeleteTexture)>(obj->mId);
+}
+
+void ClientWebGLContext::DeleteTransformFeedback(
+    WebGLTransformFeedbackJS* const obj) {
+  const FuncScope funcScope(*this, "deleteTransformFeedback");
+  if (IsContextLost()) return;
+  if (!ValidateOrSkipForDelete(*this, obj)) return;
+  const auto& state = State();
+
+  if (obj->mActiveOrPaused) {
+    EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                 "Transform Feedback object still active or paused.");
+    return;
+  }
+
+  // Unbind
+  if (state.mBoundTfo == obj) {
+    BindTransformFeedback(LOCAL_GL_TRANSFORM_FEEDBACK, nullptr);
+  }
+
+  obj->mDeleteRequested = true;
+  Run<RPROC(DeleteTransformFeedback)>(obj->mId);
+}
+
+void ClientWebGLContext::DeleteVertexArray(WebGLVertexArrayJS* const obj) {
+  const FuncScope funcScope(*this, "deleteVertexArray");
+  if (IsContextLost()) return;
+  if (!ValidateOrSkipForDelete(*this, obj)) return;
+  const auto& state = State();
+
+  // Unbind
+  if (state.mBoundVao == obj) {
+    BindVertexArray(nullptr);
+  }
+
+  obj->mDeleteRequested = true;
+  Run<RPROC(DeleteVertexArray)>(obj->mId);
+}
+
+// -
+
+bool ClientWebGLContext::IsBuffer(const WebGLBufferJS* const obj) const {
+  const FuncScope funcScope(*this, "isBuffer");
+  if (IsContextLost()) return false;
+
+  return obj && obj->IsUsable(*this) &&
+         obj->mKind != webgl::BufferKind::Undefined;
+}
+
+bool ClientWebGLContext::IsFramebuffer(
+    const WebGLFramebufferJS* const obj) const {
+  const FuncScope funcScope(*this, "isFramebuffer");
+  if (IsContextLost()) return false;
+
+  return obj && obj->IsUsable(*this) && obj->mHasBeenBound;
+}
+
+bool ClientWebGLContext::IsProgram(const WebGLProgramJS* const obj) const {
+  const FuncScope funcScope(*this, "isProgram");
+  if (IsContextLost()) return false;
+
+  return obj && obj->IsUsable(*this);
+}
+
+bool ClientWebGLContext::IsQuery(const WebGLQueryJS* const obj) const {
+  const FuncScope funcScope(*this, "isQuery");
+  if (IsContextLost()) return false;
+
+  return obj && obj->IsUsable(*this) && obj->mTarget;
+}
+
+bool ClientWebGLContext::IsRenderbuffer(
+    const WebGLRenderbufferJS* const obj) const {
+  const FuncScope funcScope(*this, "isRenderbuffer");
+  if (IsContextLost()) return false;
+
+  return obj && obj->IsUsable(*this) && obj->mHasBeenBound;
+}
+
+bool ClientWebGLContext::IsSampler(const WebGLSamplerJS* const obj) const {
+  const FuncScope funcScope(*this, "isSampler");
+  if (IsContextLost()) return false;
+
+  return obj && obj->IsUsable(*this);
+}
+
+bool ClientWebGLContext::IsShader(const WebGLShaderJS* const obj) const {
+  const FuncScope funcScope(*this, "isShader");
+  if (IsContextLost()) return false;
+
+  return obj && obj->IsUsable(*this);
+}
+
+bool ClientWebGLContext::IsSync(const WebGLSyncJS* const obj) const {
+  const FuncScope funcScope(*this, "isSync");
+  if (IsContextLost()) return false;
+
+  return obj && obj->IsUsable(*this);
+}
+
+bool ClientWebGLContext::IsTexture(const WebGLTextureJS* const obj) const {
+  const FuncScope funcScope(*this, "isTexture");
+  if (IsContextLost()) return false;
+
+  return obj && obj->IsUsable(*this) && obj->mTarget;
+}
+
+bool ClientWebGLContext::IsTransformFeedback(
+    const WebGLTransformFeedbackJS* const obj) const {
+  const FuncScope funcScope(*this, "isTransformFeedback");
+  if (IsContextLost()) return false;
+
+  return obj && obj->IsUsable(*this) && obj->mHasBeenBound;
+}
+
+bool ClientWebGLContext::IsVertexArray(
+    const WebGLVertexArrayJS* const obj) const {
+  const FuncScope funcScope(*this, "isVertexArray");
+  if (IsContextLost()) return false;
+
+  return obj && obj->IsUsable(*this) && obj->mHasBeenBound;
+}
+
+// ------------------------- GL State -------------------------
+
+void ClientWebGLContext::SetEnabledI(GLenum cap, Maybe<GLuint> i,
+                                     bool val) const {
+  Run<RPROC(SetEnabled)>(cap, i, val);
+}
+
+bool ClientWebGLContext::IsEnabled(GLenum cap) const {
+  const FuncScope funcScope(*this, "isEnabled");
+  if (IsContextLost()) return false;
+
+  const auto& inProcess = mNotLost->inProcess;
+  if (inProcess) {
+    return inProcess->IsEnabled(cap);
+  }
+  const auto& child = mNotLost->outOfProcess;
+  child->FlushPendingCmds();
+  bool ret = {};
+  if (!child->SendIsEnabled(cap, &ret)) return false;
+  return ret;
+}
+
+template <typename T, typename S>
+static JS::Value Create(JSContext* cx, nsWrapperCache* creator, const S& src,
+                        ErrorResult& rv) {
+  return JS::ObjectOrNullValue(T::Create(cx, creator, src, rv));
+}
+
+void ClientWebGLContext::GetInternalformatParameter(
+    JSContext* cx, GLenum target, GLenum internalformat, GLenum pname,
+    JS::MutableHandle<JS::Value> retval, ErrorResult& rv) {
+  const FuncScope funcScope(*this, "getInternalformatParameter");
+  retval.set(JS::NullValue());
+  const auto notLost =
+      mNotLost;  // Hold a strong-ref to prevent LoseContext=>UAF.
+  if (IsContextLost()) return;
+
+  const auto& inProcessContext = notLost->inProcess;
+  Maybe<std::vector<int32_t>> maybe;
+  if (inProcessContext) {
+    maybe = inProcessContext->GetInternalformatParameter(target, internalformat,
+                                                         pname);
+  } else {
+    const auto& child = notLost->outOfProcess;
+    child->FlushPendingCmds();
+    if (!child->SendGetInternalformatParameter(target, internalformat, pname,
+                                               &maybe)) {
+      return;
+    }
+  }
+
+  if (!maybe) {
+    return;
+  }
+
+  retval.set(Create<dom::Int32Array>(cx, this, *maybe, rv));
+}
+
+static JS::Value StringValue(JSContext* cx, const std::string& str,
+                             ErrorResult& er) {
+  JSString* jsStr = JS_NewStringCopyN(cx, str.data(), str.size());
+  if (!jsStr) {
+    er.Throw(NS_ERROR_OUT_OF_MEMORY);
+    return JS::NullValue();
+  }
+
+  return JS::StringValue(jsStr);
+}
+
+template <typename T>
+bool ToJSValueOrNull(JSContext* const cx, const RefPtr<T>& ptr,
+                     JS::MutableHandle<JS::Value> retval) {
+  if (!ptr) {
+    retval.set(JS::NullValue());
+    return true;
+  }
+  return dom::ToJSValue(cx, ptr, retval);
+}
+
+Maybe<double> ClientWebGLContext::GetNumber(const GLenum pname) {
+  MOZ_ASSERT(!IsContextLost());
+
+  const auto& inProcess = mNotLost->inProcess;
+  if (inProcess) {
+    return inProcess->GetNumber(pname);
+  }
+
+  const auto& child = mNotLost->outOfProcess;
+  child->FlushPendingCmds();
+
+  Maybe<double> ret;
+  if (!child->SendGetNumber(pname, &ret)) {
+    ret.reset();
+  }
+  return ret;
+}
+
+Maybe<std::string> ClientWebGLContext::GetString(const GLenum pname) {
+  MOZ_ASSERT(!IsContextLost());
+
+  const auto& inProcess = mNotLost->inProcess;
+  if (inProcess) {
+    return inProcess->GetString(pname);
+  }
+
+  const auto& child = mNotLost->outOfProcess;
+  child->FlushPendingCmds();
+
+  Maybe<std::string> ret;
+  if (!child->SendGetString(pname, &ret)) {
+    ret.reset();
+  }
+  return ret;
+}
+
+void ClientWebGLContext::GetParameter(JSContext* cx, GLenum pname,
+                                      JS::MutableHandle<JS::Value> retval,
+                                      ErrorResult& rv, const bool debug) {
+  retval.set(JS::NullValue());
+  const FuncScope funcScope(*this, "getParameter");
+  if (IsContextLost()) return;
+  const auto& limits = Limits();
+  const auto& state = State();
+
+  // -
+
+  const auto fnSetRetval_Buffer = [&](const GLenum target) {
+    const auto buffer = *MaybeFind(state.mBoundBufferByTarget, target);
+    (void)ToJSValueOrNull(cx, buffer, retval);
+  };
+  const auto fnSetRetval_Tex = [&](const GLenum texTarget) {
+    const auto& texUnit = state.mTexUnits[state.mActiveTexUnit];
+    const auto tex = Find(texUnit.texByTarget, texTarget, nullptr);
+    (void)ToJSValueOrNull(cx, tex, retval);
+  };
+
+  switch (pname) {
+    case LOCAL_GL_ARRAY_BUFFER_BINDING:
+      fnSetRetval_Buffer(LOCAL_GL_ARRAY_BUFFER);
+      return;
+
+    case LOCAL_GL_CURRENT_PROGRAM:
+      (void)ToJSValueOrNull(cx, state.mCurrentProgram, retval);
+      return;
+
+    case LOCAL_GL_ELEMENT_ARRAY_BUFFER_BINDING:
+      (void)ToJSValueOrNull(cx, state.mBoundVao->mIndexBuffer, retval);
+      return;
+
+    case LOCAL_GL_FRAMEBUFFER_BINDING:
+      (void)ToJSValueOrNull(cx, state.mBoundDrawFb, retval);
+      return;
+
+    case LOCAL_GL_RENDERBUFFER_BINDING:
+      (void)ToJSValueOrNull(cx, state.mBoundRb, retval);
+      return;
+
+    case LOCAL_GL_TEXTURE_BINDING_2D:
+      fnSetRetval_Tex(LOCAL_GL_TEXTURE_2D);
+      return;
+
+    case LOCAL_GL_TEXTURE_BINDING_CUBE_MAP:
+      fnSetRetval_Tex(LOCAL_GL_TEXTURE_CUBE_MAP);
+      return;
+
+    case LOCAL_GL_VERTEX_ARRAY_BINDING: {
+      if (!mIsWebGL2 &&
+          !IsExtensionEnabled(WebGLExtensionID::OES_vertex_array_object))
+        break;
+
+      auto ret = state.mBoundVao;
+      if (ret == state.mDefaultVao) {
+        ret = nullptr;
+      }
+      (void)ToJSValueOrNull(cx, ret, retval);
+      return;
+    }
+
+    case LOCAL_GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS:
+      retval.set(JS::NumberValue(limits.maxTexUnits));
+      return;
+    case LOCAL_GL_MAX_TEXTURE_SIZE:
+      retval.set(JS::NumberValue(limits.maxTex2dSize));
+      return;
+    case LOCAL_GL_MAX_CUBE_MAP_TEXTURE_SIZE:
+      retval.set(JS::NumberValue(limits.maxTexCubeSize));
+      return;
+    case LOCAL_GL_MAX_VERTEX_ATTRIBS:
+      retval.set(JS::NumberValue(limits.maxVertexAttribs));
+      return;
+
+    case LOCAL_GL_MAX_VIEWS_OVR:
+      if (IsExtensionEnabled(WebGLExtensionID::OVR_multiview2)) {
+        retval.set(JS::NumberValue(limits.maxMultiviewLayers));
+        return;
+      }
+      break;
+
+    case LOCAL_GL_PACK_ALIGNMENT:
+      retval.set(JS::NumberValue(state.mPixelPackState.alignmentInTypeElems));
+      return;
+    case LOCAL_GL_UNPACK_ALIGNMENT:
+      retval.set(JS::NumberValue(state.mPixelUnpackState.alignmentInTypeElems));
+      return;
+
+    case dom::WebGLRenderingContext_Binding::UNPACK_FLIP_Y_WEBGL:
+      retval.set(JS::BooleanValue(state.mPixelUnpackState.flipY));
+      return;
+    case dom::WebGLRenderingContext_Binding::UNPACK_PREMULTIPLY_ALPHA_WEBGL:
+      retval.set(JS::BooleanValue(state.mPixelUnpackState.premultiplyAlpha));
+      return;
+    case dom::WebGLRenderingContext_Binding::UNPACK_COLORSPACE_CONVERSION_WEBGL:
+      retval.set(JS::NumberValue(state.mPixelUnpackState.colorspaceConversion));
+      return;
+
+    case dom::WEBGL_provoking_vertex_Binding::PROVOKING_VERTEX_WEBGL:
+      if (!IsExtensionEnabled(WebGLExtensionID::WEBGL_provoking_vertex)) break;
+      retval.set(JS::NumberValue(UnderlyingValue(state.mProvokingVertex)));
+      return;
+
+    // -
+    // Array returns
+
+    // 2 floats
+    case LOCAL_GL_DEPTH_RANGE:
+      retval.set(Create<dom::Float32Array>(cx, this, state.mDepthRange, rv));
+      return;
+
+    case LOCAL_GL_ALIASED_POINT_SIZE_RANGE:
+      retval.set(
+          Create<dom::Float32Array>(cx, this, limits.pointSizeRange, rv));
+      return;
+
+    case LOCAL_GL_ALIASED_LINE_WIDTH_RANGE:
+      retval.set(
+          Create<dom::Float32Array>(cx, this, limits.lineWidthRange, rv));
+      return;
+
+    // 4 floats
+    case LOCAL_GL_COLOR_CLEAR_VALUE:
+      retval.set(Create<dom::Float32Array>(cx, this, state.mClearColor, rv));
+      return;
+
+    case LOCAL_GL_BLEND_COLOR:
+      retval.set(Create<dom::Float32Array>(cx, this, state.mBlendColor, rv));
+      return;
+
+    // 2 ints
+    case LOCAL_GL_MAX_VIEWPORT_DIMS: {
+      auto maxViewportDim = BitwiseCast<int32_t>(limits.maxViewportDim);
+      const auto dims = std::array<int32_t, 2>{maxViewportDim, maxViewportDim};
+      retval.set(Create<dom::Int32Array>(cx, this, dims, rv));
+      return;
+    }
+
+    // 4 ints
+    case LOCAL_GL_SCISSOR_BOX:
+      retval.set(Create<dom::Int32Array>(cx, this, state.mScissor, rv));
+      return;
+
+    case LOCAL_GL_VIEWPORT:
+      retval.set(Create<dom::Int32Array>(cx, this, state.mViewport, rv));
+      return;
+
+    // any
+    case LOCAL_GL_COMPRESSED_TEXTURE_FORMATS:
+      retval.set(Create<dom::Uint32Array>(cx, this,
+                                          state.mCompressedTextureFormats, rv));
+      return;
+  }
+
+  if (mIsWebGL2) {
+    switch (pname) {
+      case LOCAL_GL_COPY_READ_BUFFER_BINDING:
+        fnSetRetval_Buffer(LOCAL_GL_COPY_READ_BUFFER);
+        return;
+
+      case LOCAL_GL_COPY_WRITE_BUFFER_BINDING:
+        fnSetRetval_Buffer(LOCAL_GL_COPY_WRITE_BUFFER);
+        return;
+
+      case LOCAL_GL_DRAW_FRAMEBUFFER_BINDING:
+        (void)ToJSValueOrNull(cx, state.mBoundDrawFb, retval);
+        return;
+
+      case LOCAL_GL_PIXEL_PACK_BUFFER_BINDING:
+        fnSetRetval_Buffer(LOCAL_GL_PIXEL_PACK_BUFFER);
+        return;
+
+      case LOCAL_GL_PIXEL_UNPACK_BUFFER_BINDING:
+        fnSetRetval_Buffer(LOCAL_GL_PIXEL_UNPACK_BUFFER);
+        return;
+
+      case LOCAL_GL_READ_FRAMEBUFFER_BINDING:
+        (void)ToJSValueOrNull(cx, state.mBoundReadFb, retval);
+        return;
+
+      case LOCAL_GL_SAMPLER_BINDING: {
+        const auto& texUnit = state.mTexUnits[state.mActiveTexUnit];
+        (void)ToJSValueOrNull(cx, texUnit.sampler, retval);
+        return;
+      }
+
+      case LOCAL_GL_TEXTURE_BINDING_2D_ARRAY:
+        fnSetRetval_Tex(LOCAL_GL_TEXTURE_2D_ARRAY);
+        return;
+
+      case LOCAL_GL_TEXTURE_BINDING_3D:
+        fnSetRetval_Tex(LOCAL_GL_TEXTURE_3D);
+        return;
+
+      case LOCAL_GL_TRANSFORM_FEEDBACK_BINDING: {
+        auto ret = state.mBoundTfo;
+        if (ret == state.mDefaultTfo) {
+          ret = nullptr;
+        }
+        (void)ToJSValueOrNull(cx, ret, retval);
+        return;
+      }
+
+      case LOCAL_GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
+        fnSetRetval_Buffer(LOCAL_GL_TRANSFORM_FEEDBACK_BUFFER);
+        return;
+
+      case LOCAL_GL_UNIFORM_BUFFER_BINDING:
+        fnSetRetval_Buffer(LOCAL_GL_UNIFORM_BUFFER);
+        return;
+
+      case LOCAL_GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS:
+        retval.set(
+            JS::NumberValue(webgl::kMaxTransformFeedbackSeparateAttribs));
+        return;
+      case LOCAL_GL_MAX_UNIFORM_BUFFER_BINDINGS:
+        retval.set(JS::NumberValue(limits.maxUniformBufferBindings));
+        return;
+      case LOCAL_GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT:
+        retval.set(JS::NumberValue(limits.uniformBufferOffsetAlignment));
+        return;
+      case LOCAL_GL_MAX_3D_TEXTURE_SIZE:
+        retval.set(JS::NumberValue(limits.maxTex3dSize));
+        return;
+      case LOCAL_GL_MAX_ARRAY_TEXTURE_LAYERS:
+        retval.set(JS::NumberValue(limits.maxTexArrayLayers));
+        return;
+
+      case LOCAL_GL_PACK_ROW_LENGTH:
+        retval.set(JS::NumberValue(state.mPixelPackState.rowLength));
+        return;
+      case LOCAL_GL_PACK_SKIP_PIXELS:
+        retval.set(JS::NumberValue(state.mPixelPackState.skipPixels));
+        return;
+      case LOCAL_GL_PACK_SKIP_ROWS:
+        retval.set(JS::NumberValue(state.mPixelPackState.skipRows));
+        return;
+
+      case LOCAL_GL_UNPACK_IMAGE_HEIGHT:
+        retval.set(JS::NumberValue(state.mPixelUnpackState.imageHeight));
+        return;
+      case LOCAL_GL_UNPACK_ROW_LENGTH:
+        retval.set(JS::NumberValue(state.mPixelUnpackState.rowLength));
+        return;
+      case LOCAL_GL_UNPACK_SKIP_IMAGES:
+        retval.set(JS::NumberValue(state.mPixelUnpackState.skipImages));
+        return;
+      case LOCAL_GL_UNPACK_SKIP_PIXELS:
+        retval.set(JS::NumberValue(state.mPixelUnpackState.skipPixels));
+        return;
+      case LOCAL_GL_UNPACK_SKIP_ROWS:
+        retval.set(JS::NumberValue(state.mPixelUnpackState.skipRows));
+        return;
+    }  // switch pname
+  }    // if webgl2
+
+  // -
+
+  if (!debug) {
+    const auto GetUnmaskedRenderer = [&]() {
+      const auto prefLock = StaticPrefs::webgl_override_unmasked_renderer();
+      if (!prefLock->IsEmpty()) {
+        return Some(ToString(*prefLock));
+      }
+      return GetString(LOCAL_GL_RENDERER);
+    };
+
+    const auto GetUnmaskedVendor = [&]() {
+      const auto prefLock = StaticPrefs::webgl_override_unmasked_vendor();
+      if (!prefLock->IsEmpty()) {
+        return Some(ToString(*prefLock));
+      }
+      return GetString(LOCAL_GL_VENDOR);
+    };
+
+    // -
+
+    Maybe<std::string> ret;
+
+    switch (pname) {
+      case LOCAL_GL_VENDOR:
+        ret = Some(std::string{"Mozilla"});
+        break;
+
+      case LOCAL_GL_RENDERER: {
+        bool allowRenderer = StaticPrefs::webgl_enable_renderer_query();
+        if (ShouldResistFingerprinting(RFPTarget::WebGLRenderInfo)) {
+          allowRenderer = false;
+        }
+        if (allowRenderer) {
+          ret = GetUnmaskedRenderer();
+          if (ret) {
+            ret = Some(webgl::SanitizeRenderer(*ret));
+          }
+        }
+        if (!ret) {
+          ret = Some(std::string{"Mozilla"});
+        }
+        break;
+      }
+
+      case LOCAL_GL_VERSION:
+        if (mIsWebGL2) {
+          ret = Some(std::string{"WebGL 2.0"});
+        } else {
+          ret = Some(std::string{"WebGL 1.0"});
+        }
+        break;
+
+      case LOCAL_GL_SHADING_LANGUAGE_VERSION:
+        if (mIsWebGL2) {
+          ret = Some(std::string{"WebGL GLSL ES 3.00"});
+        } else {
+          ret = Some(std::string{"WebGL GLSL ES 1.0"});
+        }
+        break;
+
+      case dom::WEBGL_debug_renderer_info_Binding::UNMASKED_VENDOR_WEBGL:
+      case dom::WEBGL_debug_renderer_info_Binding::UNMASKED_RENDERER_WEBGL: {
+        if (!IsExtensionEnabled(WebGLExtensionID::WEBGL_debug_renderer_info)) {
+          EnqueueError_ArgEnum("pname", pname);
+          return;
+        }
+
+        switch (pname) {
+          case dom::WEBGL_debug_renderer_info_Binding::UNMASKED_RENDERER_WEBGL:
+            ret = GetUnmaskedRenderer();
+            if (ret && StaticPrefs::webgl_sanitize_unmasked_renderer()) {
+              *ret = webgl::SanitizeRenderer(*ret);
+            }
+            break;
+
+          case dom::WEBGL_debug_renderer_info_Binding::UNMASKED_VENDOR_WEBGL:
+            ret = GetUnmaskedVendor();
+            break;
+
+          default:
+            MOZ_CRASH();
+        }
+        break;
+      }
+
+      default:
+        break;
+    }
+
+    if (ret) {
+      retval.set(StringValue(cx, *ret, rv));
+      return;
+    }
+  }  // if (!debug)
+
+  // -
+
+  bool debugOnly = false;
+  bool asString = false;
+
+  switch (pname) {
+    case LOCAL_GL_EXTENSIONS:
+    case LOCAL_GL_RENDERER:
+    case LOCAL_GL_VENDOR:
+    case LOCAL_GL_VERSION:
+    case dom::MOZ_debug_Binding::WSI_INFO:
+      debugOnly = true;
+      asString = true;
+      break;
+
+    case dom::MOZ_debug_Binding::DOES_INDEX_VALIDATION:
+      debugOnly = true;
+      break;
+
+    default:
+      break;
+  }
+
+  if (debugOnly && !debug) {
+    EnqueueError_ArgEnum("pname", pname);
+    return;
+  }
+
+  // -
+
+  if (asString) {
+    const auto maybe = GetString(pname);
+    if (maybe) {
+      auto str = std::string{};
+      if (pname == dom::MOZ_debug_Binding::WSI_INFO) {
+        const auto& outOfProcess = mNotLost->outOfProcess;
+        const auto& inProcess = mNotLost->inProcess;
+        str += PrintfStdString("outOfProcess: %s\ninProcess: %s\n",
+                               ToChars(bool(outOfProcess)),
+                               ToChars(bool(inProcess)));
+      }
+      str += *maybe;
+      retval.set(StringValue(cx, str.c_str(), rv));
+    }
+  } else {
+    const auto maybe = GetNumber(pname);
+    if (maybe) {
+      switch (pname) {
+        // WebGL 1:
+        case LOCAL_GL_BLEND:
+        case LOCAL_GL_CULL_FACE:
+        case LOCAL_GL_DEPTH_TEST:
+        case LOCAL_GL_DEPTH_WRITEMASK:
+        case LOCAL_GL_DITHER:
+        case LOCAL_GL_POLYGON_OFFSET_FILL:
+        case LOCAL_GL_SAMPLE_ALPHA_TO_COVERAGE:
+        case LOCAL_GL_SAMPLE_COVERAGE:
+        case LOCAL_GL_SAMPLE_COVERAGE_INVERT:
+        case LOCAL_GL_SCISSOR_TEST:
+        case LOCAL_GL_STENCIL_TEST:
+        // WebGL 2:
+        case LOCAL_GL_RASTERIZER_DISCARD:
+        case LOCAL_GL_TRANSFORM_FEEDBACK_ACTIVE:
+        case LOCAL_GL_TRANSFORM_FEEDBACK_PAUSED:
+          retval.set(JS::BooleanValue(*maybe));
+          break;
+
+        // 4 bools
+        case LOCAL_GL_COLOR_WRITEMASK: {
+          const auto mask = uint8_t(*maybe);
+          const auto bs = std::bitset<4>(mask);
+          const auto src = std::array<bool, 4>{bs[0], bs[1], bs[2], bs[3]};
+          JS::Rooted<JS::Value> arr(cx);
+          if (!dom::ToJSValue(cx, src.data(), src.size(), &arr)) {
+            rv = NS_ERROR_OUT_OF_MEMORY;
+          }
+          retval.set(arr);
+          return;
+        }
+
+        default:
+          retval.set(JS::NumberValue(*maybe));
+          break;
+      }
+    }
+  }
+}
+
+void ClientWebGLContext::GetBufferParameter(
+    JSContext* cx, GLenum target, GLenum pname,
+    JS::MutableHandle<JS::Value> retval) const {
+  retval.set(JS::NullValue());
+  if (IsContextLost()) return;
+
+  const auto maybe = [&]() {
+    const auto& inProcess = mNotLost->inProcess;
+    if (inProcess) {
+      return inProcess->GetBufferParameter(target, pname);
+    }
+    const auto& child = mNotLost->outOfProcess;
+    child->FlushPendingCmds();
+    Maybe<double> ret;
+    if (!child->SendGetBufferParameter(target, pname, &ret)) {
+      ret.reset();
+    }
+    return ret;
+  }();
+  if (maybe) {
+    retval.set(JS::NumberValue(*maybe));
+  }
+}
+
+bool IsFramebufferTarget(const bool isWebgl2, const GLenum target) {
+  switch (target) {
+    case LOCAL_GL_FRAMEBUFFER:
+      return true;
+
+    case LOCAL_GL_DRAW_FRAMEBUFFER:
+    case LOCAL_GL_READ_FRAMEBUFFER:
+      return isWebgl2;
+
+    default:
+      return false;
+  }
+}
+
+void ClientWebGLContext::GetFramebufferAttachmentParameter(
+    JSContext* const cx, const GLenum target, const GLenum attachment,
+    const GLenum pname, JS::MutableHandle<JS::Value> retval,
+    ErrorResult& rv) const {
+  retval.set(JS::NullValue());
+  const FuncScope funcScope(*this, "getFramebufferAttachmentParameter");
+  if (IsContextLost()) return;
+
+  const auto& state = State();
+
+  if (!IsFramebufferTarget(mIsWebGL2, target)) {
+    EnqueueError_ArgEnum("target", target);
+    return;
+  }
+  auto fb = state.mBoundDrawFb;
+  if (target == LOCAL_GL_READ_FRAMEBUFFER) {
+    fb = state.mBoundReadFb;
+  }
+
+  const auto fnGet = [&](const GLenum pname) {
+    const auto fbId = fb ? fb->mId : 0;
+
+    const auto& inProcess = mNotLost->inProcess;
+    if (inProcess) {
+      return inProcess->GetFramebufferAttachmentParameter(fbId, attachment,
+                                                          pname);
+    }
+    const auto& child = mNotLost->outOfProcess;
+    child->FlushPendingCmds();
+    Maybe<double> ret;
+    if (!child->SendGetFramebufferAttachmentParameter(fbId, attachment, pname,
+                                                      &ret)) {
+      ret.reset();
+    }
+    return ret;
+  };
+
+  if (fb) {
+    if (fb->mOpaque) {
+      EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                   "An opaque framebuffer's attachments cannot be inspected or "
+                   "changed.");
+      return;
+    }
+    auto attachmentSlotEnum = attachment;
+    if (mIsWebGL2 && attachment == LOCAL_GL_DEPTH_STENCIL_ATTACHMENT) {
+      // In webgl2, DEPTH_STENCIL is valid iff the DEPTH and STENCIL images
+      // match, so check if the server errors.
+      const auto maybe = fnGet(LOCAL_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE);
+      if (!maybe) return;
+      attachmentSlotEnum = LOCAL_GL_DEPTH_ATTACHMENT;
+    }
+
+    const auto maybeSlot = fb->GetAttachment(attachmentSlotEnum);
+    if (!maybeSlot) {
+      EnqueueError_ArgEnum("attachment", attachment);
+      return;
+    }
+    const auto& attached = *maybeSlot;
+
+    // -
+
+    if (pname == LOCAL_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME) {
+      if (attached.rb) {
+        (void)ToJSValueOrNull(cx, attached.rb, retval);
+      } else {
+        if (!mIsWebGL2 && !attached.tex) {
+          EnqueueError_ArgEnum("pname", pname);
+          return;
+        }
+        (void)ToJSValueOrNull(cx, attached.tex, retval);
+      }
+      return;
+    }
+  }
+
+  const auto maybe = fnGet(pname);
+  if (maybe) {
+    retval.set(JS::NumberValue(*maybe));
+  }
+}
+
+void ClientWebGLContext::GetRenderbufferParameter(
+    JSContext* cx, GLenum target, GLenum pname,
+    JS::MutableHandle<JS::Value> retval) const {
+  retval.set(JS::NullValue());
+  const FuncScope funcScope(*this, "getRenderbufferParameter");
+  if (IsContextLost()) return;
+
+  if (target != LOCAL_GL_RENDERBUFFER) {
+    EnqueueError_ArgEnum("target", target);
+    return;
+  }
+
+  const auto& state = State();
+  const auto& rb = state.mBoundRb;
+  const auto rbId = rb ? rb->mId : 0;
+  const auto maybe = [&]() {
+    const auto& inProcess = mNotLost->inProcess;
+    if (inProcess) {
+      return inProcess->GetRenderbufferParameter(rbId, pname);
+    }
+    const auto& child = mNotLost->outOfProcess;
+    child->FlushPendingCmds();
+    Maybe<double> ret;
+    if (!child->SendGetRenderbufferParameter(rbId, pname, &ret)) {
+      ret.reset();
+    }
+    return ret;
+  }();
+  if (maybe) {
+    retval.set(JS::NumberValue(*maybe));
+  }
+}
+
+void ClientWebGLContext::GetIndexedParameter(
+    JSContext* cx, GLenum target, GLuint index,
+    JS::MutableHandle<JS::Value> retval, ErrorResult& rv) const {
+  retval.set(JS::NullValue());
+  const FuncScope funcScope(*this, "getIndexedParameter");
+  if (IsContextLost()) return;
+
+  const auto& state = State();
+
+  switch (target) {
+    case LOCAL_GL_TRANSFORM_FEEDBACK_BUFFER_BINDING: {
+      const auto& list = state.mBoundTfo->mAttribBuffers;
+      if (index >= list.size()) {
+        EnqueueError(LOCAL_GL_INVALID_VALUE,
+                     "`index` (%u) >= MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS",
+                     index);
+        return;
+      }
+      (void)ToJSValueOrNull(cx, list[index], retval);
+      return;
+    }
+
+    case LOCAL_GL_UNIFORM_BUFFER_BINDING: {
+      const auto& list = state.mBoundUbos;
+      if (index >= list.size()) {
+        EnqueueError(LOCAL_GL_INVALID_VALUE,
+                     "`index` (%u) >= MAX_UNIFORM_BUFFER_BINDINGS", index);
+        return;
+      }
+      (void)ToJSValueOrNull(cx, list[index], retval);
+      return;
+    }
+  }
+
+  const auto maybe = [&]() {
+    const auto& inProcess = mNotLost->inProcess;
+    if (inProcess) {
+      return inProcess->GetIndexedParameter(target, index);
+    }
+    const auto& child = mNotLost->outOfProcess;
+    child->FlushPendingCmds();
+    Maybe<double> ret;
+    if (!child->SendGetIndexedParameter(target, index, &ret)) {
+      ret.reset();
+    }
+    return ret;
+  }();
+  if (maybe) {
+    switch (target) {
+      case LOCAL_GL_COLOR_WRITEMASK: {
+        const auto bs = std::bitset<4>(*maybe);
+        const auto src = std::array<bool, 4>{bs[0], bs[1], bs[2], bs[3]};
+        JS::Rooted<JS::Value> arr(cx);
+        if (!dom::ToJSValue(cx, src.data(), src.size(), &arr)) {
+          rv = NS_ERROR_OUT_OF_MEMORY;
+        }
+        retval.set(arr);
+        return;
+      }
+
+      default:
+        retval.set(JS::NumberValue(*maybe));
+        return;
+    }
+  }
+}
+
+void ClientWebGLContext::GetUniform(JSContext* const cx,
+                                    const WebGLProgramJS& prog,
+                                    const WebGLUniformLocationJS& loc,
+                                    JS::MutableHandle<JS::Value> retval) {
+  retval.set(JS::NullValue());
+  const FuncScope funcScope(*this, "getUniform");
+  if (IsContextLost()) return;
+  if (!prog.ValidateUsable(*this, "prog")) return;
+  if (!loc.ValidateUsable(*this, "loc")) return;
+
+  const auto& progLinkResult = GetLinkResult(prog);
+  if (!progLinkResult.success) {
+    EnqueueError(LOCAL_GL_INVALID_OPERATION, "Program is not linked.");
+    return;
+  }
+  const auto& uniformLinkResult = loc.mParent.lock();
+  if (uniformLinkResult.get() != &progLinkResult) {
+    EnqueueError(
+        LOCAL_GL_INVALID_OPERATION,
+        "UniformLocation is not from the most recent linking of Program.");
+    return;
+  }
+
+  const auto res = [&]() {
+    const auto& inProcess = mNotLost->inProcess;
+    if (inProcess) {
+      return inProcess->GetUniform(prog.mId, loc.mLocation);
+    }
+    const auto& child = mNotLost->outOfProcess;
+    child->FlushPendingCmds();
+    webgl::GetUniformData ret;
+    if (!child->SendGetUniform(prog.mId, loc.mLocation, &ret)) {
+      ret = {};
+    }
+    return ret;
+  }();
+  if (!res.type) return;
+
+  const auto elemCount = ElemTypeComponents(res.type);
+  MOZ_ASSERT(elemCount);
+
+  switch (res.type) {
+    case LOCAL_GL_BOOL:
+      retval.set(JS::BooleanValue(res.data[0]));
+      return;
+
+    case LOCAL_GL_FLOAT: {
+      const auto ptr = reinterpret_cast<const float*>(res.data);
+      MOZ_ALWAYS_TRUE(dom::ToJSValue(cx, *ptr, retval));
+      return;
+    }
+    case LOCAL_GL_INT: {
+      const auto ptr = reinterpret_cast<const int32_t*>(res.data);
+      MOZ_ALWAYS_TRUE(dom::ToJSValue(cx, *ptr, retval));
+      return;
+    }
+    case LOCAL_GL_UNSIGNED_INT:
+    case LOCAL_GL_SAMPLER_2D:
+    case LOCAL_GL_SAMPLER_3D:
+    case LOCAL_GL_SAMPLER_CUBE:
+    case LOCAL_GL_SAMPLER_2D_SHADOW:
+    case LOCAL_GL_SAMPLER_2D_ARRAY:
+    case LOCAL_GL_SAMPLER_2D_ARRAY_SHADOW:
+    case LOCAL_GL_SAMPLER_CUBE_SHADOW:
+    case LOCAL_GL_INT_SAMPLER_2D:
+    case LOCAL_GL_INT_SAMPLER_3D:
+    case LOCAL_GL_INT_SAMPLER_CUBE:
+    case LOCAL_GL_INT_SAMPLER_2D_ARRAY:
+    case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D:
+    case LOCAL_GL_UNSIGNED_INT_SAMPLER_3D:
+    case LOCAL_GL_UNSIGNED_INT_SAMPLER_CUBE:
+    case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D_ARRAY: {
+      const auto ptr = reinterpret_cast<const uint32_t*>(res.data);
+      MOZ_ALWAYS_TRUE(dom::ToJSValue(cx, *ptr, retval));
+      return;
+    }
+
+      // -
+
+    case LOCAL_GL_BOOL_VEC2:
+    case LOCAL_GL_BOOL_VEC3:
+    case LOCAL_GL_BOOL_VEC4: {
+      const auto intArr = reinterpret_cast<const int32_t*>(res.data);
+      bool boolArr[4] = {};
+      for (const auto i : IntegerRange(elemCount)) {
+        boolArr[i] = bool(intArr[i]);
+      }
+      MOZ_ALWAYS_TRUE(dom::ToJSValue(cx, boolArr, elemCount, retval));
+      return;
+    }
+
+    case LOCAL_GL_FLOAT_VEC2:
+    case LOCAL_GL_FLOAT_VEC3:
+    case LOCAL_GL_FLOAT_VEC4:
+    case LOCAL_GL_FLOAT_MAT2:
+    case LOCAL_GL_FLOAT_MAT3:
+    case LOCAL_GL_FLOAT_MAT4:
+    case LOCAL_GL_FLOAT_MAT2x3:
+    case LOCAL_GL_FLOAT_MAT2x4:
+    case LOCAL_GL_FLOAT_MAT3x2:
+    case LOCAL_GL_FLOAT_MAT3x4:
+    case LOCAL_GL_FLOAT_MAT4x2:
+    case LOCAL_GL_FLOAT_MAT4x3: {
+      const auto ptr = reinterpret_cast<const float*>(res.data);
+      IgnoredErrorResult error;
+      JSObject* obj =
+          dom::Float32Array::Create(cx, this, Span(ptr, elemCount), error);
+      MOZ_ASSERT(obj);
+      retval.set(JS::ObjectOrNullValue(obj));
+      return;
+    }
+
+    case LOCAL_GL_INT_VEC2:
+    case LOCAL_GL_INT_VEC3:
+    case LOCAL_GL_INT_VEC4: {
+      const auto ptr = reinterpret_cast<const int32_t*>(res.data);
+      IgnoredErrorResult error;
+      JSObject* obj =
+          dom::Int32Array::Create(cx, this, Span(ptr, elemCount), error);
+      MOZ_ASSERT(obj);
+      retval.set(JS::ObjectOrNullValue(obj));
+      return;
+    }
+
+    case LOCAL_GL_UNSIGNED_INT_VEC2:
+    case LOCAL_GL_UNSIGNED_INT_VEC3:
+    case LOCAL_GL_UNSIGNED_INT_VEC4: {
+      const auto ptr = reinterpret_cast<const uint32_t*>(res.data);
+      IgnoredErrorResult error;
+      JSObject* obj =
+          dom::Uint32Array::Create(cx, this, Span(ptr, elemCount), error);
+      MOZ_ASSERT(obj);
+      retval.set(JS::ObjectOrNullValue(obj));
+      return;
+    }
+
+    default:
+      MOZ_CRASH("GFX: Invalid elemType.");
+  }
+}
+
+already_AddRefed<WebGLShaderPrecisionFormatJS>
+ClientWebGLContext::GetShaderPrecisionFormat(const GLenum shadertype,
+                                             const GLenum precisiontype) {
+  if (IsContextLost()) 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;
+  }();
+
+  if (!info) return nullptr;
+  return AsAddRefed(new WebGLShaderPrecisionFormatJS(*info));
+}
+
+void ClientWebGLContext::BlendColor(GLclampf r, GLclampf g, GLclampf b,
+                                    GLclampf a) {
+  const FuncScope funcScope(*this, "blendColor");
+  if (IsContextLost()) return;
+  auto& state = State();
+
+  auto& cache = state.mBlendColor;
+  cache[0] = r;
+  cache[1] = g;
+  cache[2] = b;
+  cache[3] = a;
+
+  Run<RPROC(BlendColor)>(r, g, b, a);
+}
+
+void ClientWebGLContext::BlendEquationSeparateI(Maybe<GLuint> i, GLenum modeRGB,
+                                                GLenum modeAlpha) {
+  Run<RPROC(BlendEquationSeparate)>(i, modeRGB, modeAlpha);
+}
+
+void ClientWebGLContext::BlendFuncSeparateI(Maybe<GLuint> i, GLenum srcRGB,
+                                            GLenum dstRGB, GLenum srcAlpha,
+                                            GLenum dstAlpha) {
+  Run<RPROC(BlendFuncSeparate)>(i, srcRGB, dstRGB, srcAlpha, dstAlpha);
+}
+
+GLenum ClientWebGLContext::CheckFramebufferStatus(GLenum target) {
+  if (IsContextLost()) return LOCAL_GL_FRAMEBUFFER_UNSUPPORTED;
+
+  const auto& inProcess = mNotLost->inProcess;
+  if (inProcess) {
+    return inProcess->CheckFramebufferStatus(target);
+  }
+  const auto& child = mNotLost->outOfProcess;
+  child->FlushPendingCmds();
+  GLenum ret = 0;
+  if (!child->SendCheckFramebufferStatus(target, &ret)) {
+    ret = 0;
+  }
+  return ret;
+}
+
+void ClientWebGLContext::Clear(GLbitfield mask) {
+  Run<RPROC(Clear)>(mask);
+
+  AfterDrawCall();
+}
+
+// -
+
+void ClientWebGLContext::ClearBufferTv(const GLenum buffer,
+                                       const GLint drawBuffer,
+                                       const webgl::AttribBaseType type,
+                                       JS::AutoCheckCannotGC&& nogc,
+                                       const Span<const uint8_t>& view,
+                                       const GLuint srcElemOffset) {
+  if (IsContextLost()) return;
+
+  const auto byteOffset = CheckedInt<size_t>(srcElemOffset) * sizeof(float);
+  if (!byteOffset.isValid() || byteOffset.value() > view.Length()) {
+    nogc.reset();
+    EnqueueError(LOCAL_GL_INVALID_VALUE, "`srcOffset` too large for `values`.");
+    return;
+  }
+  webgl::TypedQuad data;
+  data.type = type;
+
+  auto dataSize = data.data.size();
+  switch (buffer) {
+    case LOCAL_GL_COLOR:
+      break;
+
+    case LOCAL_GL_DEPTH:
+      dataSize = sizeof(float);
+      break;
+
+    case LOCAL_GL_STENCIL:
+      dataSize = sizeof(int32_t);
+      break;
+
+    default:
+      nogc.reset();
+      EnqueueError_ArgEnum("buffer", buffer);
+      return;
+  }
+
+  const auto requiredBytes = byteOffset + dataSize;
+  if (!requiredBytes.isValid() || requiredBytes.value() > view.Length()) {
+    nogc.reset();
+    EnqueueError(LOCAL_GL_INVALID_VALUE, "`values` too small.");
+    return;
+  }
+
+  memcpy(data.data.data(), view.data() + byteOffset.value(), dataSize);
+  nogc.reset();  // Done with `view`.
+  Run<RPROC(ClearBufferTv)>(buffer, drawBuffer, data);
+
+  AfterDrawCall();
+}
+
+void ClientWebGLContext::ClearBufferfi(GLenum buffer, GLint drawBuffer,
+                                       GLfloat depth, GLint stencil) {
+  Run<RPROC(ClearBufferfi)>(buffer, drawBuffer, depth, stencil);
+
+  AfterDrawCall();
+}
+
+// -
+
+void ClientWebGLContext::ClearColor(GLclampf r, GLclampf g, GLclampf b,
+                                    GLclampf a) {
+  const FuncScope funcScope(*this, "clearColor");
+  if (IsContextLost()) return;
+  auto& state = State();
+
+  auto& cache = state.mClearColor;
+  cache[0] = r;
+  cache[1] = g;
+  cache[2] = b;
+  cache[3] = a;
+
+  Run<RPROC(ClearColor)>(r, g, b, a);
+}
+
+void ClientWebGLContext::ClearDepth(GLclampf v) { Run<RPROC(ClearDepth)>(v); }
+
+void ClientWebGLContext::ClearStencil(GLint v) { Run<RPROC(ClearStencil)>(v); }
+
+void ClientWebGLContext::ColorMaskI(Maybe<GLuint> i, bool r, bool g, bool b,
+                                    bool a) const {
+  const FuncScope funcScope(*this, "colorMask");
+  if (IsContextLost()) return;
+
+  const uint8_t mask =
+      uint8_t(r << 0) | uint8_t(g << 1) | uint8_t(b << 2) | uint8_t(a << 3);
+  Run<RPROC(ColorMask)>(i, mask);
+}
+
+void ClientWebGLContext::CullFace(GLenum face) { Run<RPROC(CullFace)>(face); }
+
+void ClientWebGLContext::DepthFunc(GLenum func) { Run<RPROC(DepthFunc)>(func); }
+
+void ClientWebGLContext::DepthMask(WebGLboolean b) { Run<RPROC(DepthMask)>(b); }
+
+void ClientWebGLContext::DepthRange(GLclampf zNear, GLclampf zFar) {
+  const FuncScope funcScope(*this, "depthRange");
+  if (IsContextLost()) return;
+  auto& state = State();
+
+  state.mDepthRange = {zNear, zFar};
+
+  Run<RPROC(DepthRange)>(zNear, zFar);
+}
+
+void ClientWebGLContext::Flush(const bool flushGl) {
+  const FuncScope funcScope(*this, "flush");
+  if (IsContextLost()) return;
+
+  if (flushGl) {
+    Run<RPROC(Flush)>();
+  }
+
+  if (mNotLost->inProcess) return;
+  const auto& child = mNotLost->outOfProcess;
+  child->FlushPendingCmds();
+}
+
+void ClientWebGLContext::Finish() {
+  if (IsContextLost()) return;
+
+  const auto& inProcess = mNotLost->inProcess;
+  if (inProcess) {
+    inProcess->Finish();
+    return;
+  }
+  const auto& child = mNotLost->outOfProcess;
+  child->FlushPendingCmds();
+  (void)child->SendFinish();
+}
+
+void ClientWebGLContext::FrontFace(GLenum mode) { Run<RPROC(FrontFace)>(mode); }
+
+GLenum ClientWebGLContext::GetError() {
+  const FuncScope funcScope(*this, "getError");
+  if (mNextError) {
+    const auto ret = mNextError;
+    mNextError = 0;
+    return ret;
+  }
+  if (IsContextLost()) return 0;
+
+  const auto& inProcess = mNotLost->inProcess;
+  if (inProcess) {
+    return inProcess->GetError();
+  }
+  const auto& child = mNotLost->outOfProcess;
+  child->FlushPendingCmds();
+  GLenum ret = 0;
+  if (!child->SendGetError(&ret)) {
+    ret = 0;
+  }
+  return ret;
+}
+
+void ClientWebGLContext::Hint(GLenum target, GLenum mode) {
+  Run<RPROC(Hint)>(target, mode);
+}
+
+void ClientWebGLContext::LineWidth(GLfloat width) {
+  Run<RPROC(LineWidth)>(width);
+}
+
+Maybe<webgl::ErrorInfo> SetPixelUnpack(
+    const bool isWebgl2, webgl::PixelUnpackStateWebgl* const unpacking,
+    const GLenum pname, const GLint param);
+
+void ClientWebGLContext::PixelStorei(const GLenum pname, const GLint iparam) {
+  const FuncScope funcScope(*this, "pixelStorei");
+  if (IsContextLost()) return;
+  if (!ValidateNonNegative("param", iparam)) return;
+  const auto param = static_cast<uint32_t>(iparam);
+
+  auto& state = State();
+  auto& packState = state.mPixelPackState;
+  switch (pname) {
+    case LOCAL_GL_PACK_ALIGNMENT:
+      switch (param) {
+        case 1:
+        case 2:
+        case 4:
+        case 8:
+          break;
+        default:
+          EnqueueError(LOCAL_GL_INVALID_VALUE,
+                       "PACK_ALIGNMENT must be one of [1,2,4,8], was %i.",
+                       iparam);
+          return;
+      }
+      packState.alignmentInTypeElems = param;
+      return;
+
+    case LOCAL_GL_PACK_ROW_LENGTH:
+      if (!mIsWebGL2) break;
+      packState.rowLength = param;
+      return;
+
+    case LOCAL_GL_PACK_SKIP_PIXELS:
+      if (!mIsWebGL2) break;
+      packState.skipPixels = param;
+      return;
+
+    case LOCAL_GL_PACK_SKIP_ROWS:
+      if (!mIsWebGL2) break;
+      packState.skipRows = param;
+      return;
+
+    case dom::MOZ_debug_Binding::UNPACK_REQUIRE_FASTPATH:
+      if (!IsSupported(WebGLExtensionID::MOZ_debug)) {
+        EnqueueError_ArgEnum("pname", pname);
+        return;
+      }
+      break;
+
+    default:
+      break;
+  }
+
+  const auto err =
+      SetPixelUnpack(mIsWebGL2, &state.mPixelUnpackState, pname, iparam);
+  if (err) {
+    EnqueueError(*err);
+    return;
+  }
+}
+
+void ClientWebGLContext::PolygonOffset(GLfloat factor, GLfloat units) {
+  Run<RPROC(PolygonOffset)>(factor, units);
+}
+
+void ClientWebGLContext::SampleCoverage(GLclampf value, WebGLboolean invert) {
+  Run<RPROC(SampleCoverage)>(value, invert);
+}
+
+void ClientWebGLContext::Scissor(GLint x, GLint y, GLsizei width,
+                                 GLsizei height) {
+  const FuncScope funcScope(*this, "scissor");
+  if (IsContextLost()) return;
+  auto& state = State();
+
+  if (!ValidateNonNegative("width", width) ||
+      !ValidateNonNegative("height", height)) {
+    return;
+  }
+
+  state.mScissor = {x, y, width, height};
+
+  Run<RPROC(Scissor)>(x, y, width, height);
+}
+
+void ClientWebGLContext::StencilFuncSeparate(GLenum face, GLenum func,
+                                             GLint ref, GLuint mask) {
+  Run<RPROC(StencilFuncSeparate)>(face, func, ref, mask);
+}
+
+void ClientWebGLContext::StencilMaskSeparate(GLenum face, GLuint mask) {
+  Run<RPROC(StencilMaskSeparate)>(face, mask);
+}
+
+void ClientWebGLContext::StencilOpSeparate(GLenum face, GLenum sfail,
+                                           GLenum dpfail, GLenum dppass) {
+  Run<RPROC(StencilOpSeparate)>(face, sfail, dpfail, dppass);
+}
+
+void ClientWebGLContext::Viewport(GLint x, GLint y, GLsizei width,
+                                  GLsizei height) {
+  const FuncScope funcScope(*this, "viewport");
+  if (IsContextLost()) return;
+  auto& state = State();
+
+  if (!ValidateNonNegative("width", width) ||
+      !ValidateNonNegative("height", height)) {
+    return;
+  }
+
+  state.mViewport = {x, y, width, height};
+
+  Run<RPROC(Viewport)>(x, y, width, height);
+}
+
+// ------------------------- Buffer Objects -------------------------
+
+Maybe<const webgl::ErrorInfo> ValidateBindBuffer(
+    const GLenum target, const webgl::BufferKind curKind) {
+  if (curKind == webgl::BufferKind::Undefined) return {};
+
+  auto requiredKind = webgl::BufferKind::NonIndex;
+  switch (target) {
+    case LOCAL_GL_COPY_READ_BUFFER:
+    case LOCAL_GL_COPY_WRITE_BUFFER:
+      return {};  // Always ok
+
+    case LOCAL_GL_ELEMENT_ARRAY_BUFFER:
+      requiredKind = webgl::BufferKind::Index;
+      break;
+
+    default:
+      break;
+  }
+
+  if (curKind != requiredKind) {
+    const auto fnKindStr = [&](const webgl::BufferKind kind) {
+      if (kind == webgl::BufferKind::Index) return "ELEMENT_ARRAY_BUFFER";
+      return "non-ELEMENT_ARRAY_BUFFER";
+    };
+    const auto info = nsPrintfCString(
+        "Buffer previously bound to %s cannot be now bound to %s.",
+        fnKindStr(curKind), fnKindStr(requiredKind));
+    return Some(
+        webgl::ErrorInfo{LOCAL_GL_INVALID_OPERATION, info.BeginReading()});
+  }
+
+  return {};
+}
+
+Maybe<webgl::ErrorInfo> CheckBindBufferRange(
+    const GLenum target, const GLuint index, const bool isBuffer,
+    const uint64_t offset, const uint64_t size, const webgl::Limits& limits) {
+  const auto fnSome = [&](const GLenum type, const nsACString& info) {
+    return Some(webgl::ErrorInfo{type, info.BeginReading()});
+  };
+
+  switch (target) {
+    case LOCAL_GL_TRANSFORM_FEEDBACK_BUFFER:
+      if (index >= webgl::kMaxTransformFeedbackSeparateAttribs) {
+        const auto info = nsPrintfCString(
+            "`index` (%u) must be less than "
+            "MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS (%u).",
+            index, webgl::kMaxTransformFeedbackSeparateAttribs);
+        return fnSome(LOCAL_GL_INVALID_VALUE, info);
+      }
+
+      if (offset % 4 != 0 || size % 4 != 0) {
+        const auto info =
+            nsPrintfCString("`offset` (%" PRIu64 ") and `size` (%" PRIu64
+                            ") must both be aligned to 4 for"
+                            " TRANSFORM_FEEDBACK_BUFFER.",
+                            offset, size);
+        return fnSome(LOCAL_GL_INVALID_VALUE, info);
+      }
+      break;
+
+    case LOCAL_GL_UNIFORM_BUFFER:
+      if (index >= limits.maxUniformBufferBindings) {
+        const auto info = nsPrintfCString(
+            "`index` (%u) must be less than MAX_UNIFORM_BUFFER_BINDINGS (%u).",
+            index, limits.maxUniformBufferBindings);
+        return fnSome(LOCAL_GL_INVALID_VALUE, info);
+      }
+
+      if (offset % limits.uniformBufferOffsetAlignment != 0) {
+        const auto info =
+            nsPrintfCString("`offset` (%" PRIu64
+                            ") must be aligned to "
+                            "UNIFORM_BUFFER_OFFSET_ALIGNMENT (%u).",
+                            offset, limits.uniformBufferOffsetAlignment);
+        return fnSome(LOCAL_GL_INVALID_VALUE, info);
+      }
+      break;
+
+    default: {
+      const auto info =
+          nsPrintfCString("Unrecognized `target`: 0x%04x", target);
+      return fnSome(LOCAL_GL_INVALID_ENUM, info);
+    }
+  }
+
+  return {};
+}
+
+// -
+
+void ClientWebGLContext::BindBuffer(const GLenum target,
+                                    WebGLBufferJS* const buffer) {
+  const FuncScope funcScope(*this, "bindBuffer");
+  if (IsContextLost()) return;
+  if (buffer && !buffer->ValidateUsable(*this, "buffer")) return;
+
+  // -
+  // Check for INVALID_ENUM
+
+  auto& state = State();
+  auto* slot = &(state.mBoundVao->mIndexBuffer);
+  if (target != LOCAL_GL_ELEMENT_ARRAY_BUFFER) {
+    const auto itr = state.mBoundBufferByTarget.find(target);
+    if (itr == state.mBoundBufferByTarget.end()) {
+      EnqueueError_ArgEnum("target", target);
+      return;
+    }
+    slot = &(itr->second);
+  }
+
+  // -
+
+  auto kind = webgl::BufferKind::Undefined;
+  if (buffer) {
+    kind = buffer->mKind;
+  }
+  const auto err = ValidateBindBuffer(target, kind);
+  if (err) {
+    EnqueueError(err->type, "%s", err->info.c_str());
+    return;
+  }
+
+  // -
+  // Validation complete
+
+  if (buffer && buffer->mKind == webgl::BufferKind::Undefined) {
+    if (target == LOCAL_GL_ELEMENT_ARRAY_BUFFER) {
+      buffer->mKind = webgl::BufferKind::Index;
+    } else {
+      buffer->mKind = webgl::BufferKind::NonIndex;
+    }
+  }
+  *slot = buffer;
+
+  // -
+
+  Run<RPROC(BindBuffer)>(target, buffer ? buffer->mId : 0);
+}
+
+// -
+
+void ClientWebGLContext::BindBufferRangeImpl(const GLenum target,
+                                             const GLuint index,
+                                             WebGLBufferJS* const buffer,
+                                             const uint64_t offset,
+                                             const uint64_t size) {
+  if (buffer && !buffer->ValidateUsable(*this, "buffer")) return;
+  auto& state = State();
+
+  // -
+
+  const auto& limits = Limits();
+  auto err =
+      CheckBindBufferRange(target, index, bool(buffer), offset, size, limits);
+  if (err) {
+    EnqueueError(err->type, "%s", err->info.c_str());
+    return;
+  }
+
+  // -
+
+  auto kind = webgl::BufferKind::Undefined;
+  if (buffer) {
+    kind = buffer->mKind;
+  }
+  err = ValidateBindBuffer(target, kind);
+  if (err) {
+    EnqueueError(err->type, "%s", err->info.c_str());
+    return;
+  }
+
+  if (target == LOCAL_GL_TRANSFORM_FEEDBACK_BUFFER) {
+    if (state.mTfActiveAndNotPaused) {
+      EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                   "Cannot change TRANSFORM_FEEDBACK_BUFFER while "
+                   "TransformFeedback is active and not paused.");
+      return;
+    }
+  }
+
+  // -
+  // Validation complete
+
+  if (buffer && buffer->mKind == webgl::BufferKind::Undefined) {
+    buffer->mKind = webgl::BufferKind::NonIndex;
+  }
+
+  // -
+
+  switch (target) {
+    case LOCAL_GL_TRANSFORM_FEEDBACK_BUFFER:
+      state.mBoundTfo->mAttribBuffers[index] = buffer;
+      break;
+
+    case LOCAL_GL_UNIFORM_BUFFER:
+      state.mBoundUbos[index] = buffer;
+      break;
+
+    default:
+      MOZ_CRASH("Bad `target`");
+  }
+  state.mBoundBufferByTarget[target] = buffer;
+
+  // -
+
+  Run<RPROC(BindBufferRange)>(target, index, buffer ? buffer->mId : 0, offset,
+                              size);
+}
+
+static inline size_t SizeOfViewElem(const dom::ArrayBufferView& view) {
+  const auto& elemType = view.Type();
+  if (elemType == js::Scalar::MaxTypedArrayViewType)  // DataViews.
+    return 1;
+
+  return js::Scalar::byteSize(elemType);
+}
+
+void ClientWebGLContext::GetBufferSubData(GLenum target, GLintptr srcByteOffset,
+                                          const dom::ArrayBufferView& dstData,
+                                          GLuint dstElemOffset,
+                                          GLuint dstElemCountOverride) {
+  const FuncScope funcScope(*this, "getBufferSubData");
+  if (IsContextLost()) return;
+  const auto notLost =
+      mNotLost;  // Hold a strong-ref to prevent LoseContext=>UAF.
+  if (!ValidateNonNegative("srcByteOffset", srcByteOffset)) return;
+
+  size_t elemSize = SizeOfViewElem(dstData);
+  dstData.ProcessFixedData([&](const Span<uint8_t>& aData) {
+    const auto& destView =
+        ValidateArrayBufferView(aData, elemSize, dstElemOffset,
+                                dstElemCountOverride, LOCAL_GL_INVALID_VALUE);
+    if (!destView) {
+      return;
+    }
+
+    const auto& inProcessContext = notLost->inProcess;
+    if (inProcessContext) {
+      inProcessContext->GetBufferSubData(target, srcByteOffset, *destView);
+      return;
+    }
+
+    const auto& child = notLost->outOfProcess;
+    child->FlushPendingCmds();
+    mozilla::ipc::Shmem rawShmem;
+    if (!child->SendGetBufferSubData(target, srcByteOffset, destView->length(),
+                                     &rawShmem)) {
+      return;
+    }
+    const webgl::RaiiShmem shmem{child, rawShmem};
+    if (!shmem) {
+      EnqueueError(LOCAL_GL_OUT_OF_MEMORY, "Failed to map in sub data buffer.");
+      return;
+    }
+
+    const auto shmemView = shmem.ByteRange();
+    MOZ_RELEASE_ASSERT(shmemView.length() == 1 + destView->length());
+
+    const auto ok = bool(*(shmemView.begin().get()));
+    const auto srcView =
+        Range<const uint8_t>{shmemView.begin() + 1, shmemView.end()};
+    if (ok) {
+      Memcpy(destView->begin(), srcView.begin(), srcView.length());
+    }
+  });
+}
+
+////
+
+void ClientWebGLContext::BufferData(GLenum target, WebGLsizeiptr rawSize,
+                                    GLenum usage) {
+  const FuncScope funcScope(*this, "bufferData");
+  if (!ValidateNonNegative("size", rawSize)) return;
+
+  const auto size = MaybeAs<size_t>(rawSize);
+  if (!size) {
+    EnqueueError(LOCAL_GL_OUT_OF_MEMORY, "`size` too large for platform.");
+    return;
+  }
+  Run<RPROC(BufferData_SizeOnly)>(target, *size, usage);
+}
+
+void ClientWebGLContext::BufferData(
+    GLenum target, const dom::Nullable<dom::ArrayBuffer>& maybeSrc,
+    GLenum usage) {
+  const FuncScope funcScope(*this, "bufferData");
+  if (!ValidateNonNull("src", maybeSrc)) return;
+  const auto& src = maybeSrc.Value();
+
+  src.ProcessFixedData([&](const Span<uint8_t>& aData) {
+    Run<RPROC(BufferData)>(target, RawBuffer<>(aData), usage);
+  });
+}
+
+void ClientWebGLContext::BufferData(GLenum target,
+                                    const dom::ArrayBufferView& src,
+                                    GLenum usage, GLuint srcElemOffset,
+                                    GLuint srcElemCountOverride) {
+  const FuncScope funcScope(*this, "bufferData");
+  size_t elemSize = SizeOfViewElem(src);
+  src.ProcessFixedData([&](const Span<uint8_t>& aData) {
+    const auto& range =
+        ValidateArrayBufferView(aData, elemSize, srcElemOffset,
+                                srcElemCountOverride, LOCAL_GL_INVALID_VALUE);
+    if (!range) {
+      return;
+    }
+    Run<RPROC(BufferData)>(target, RawBuffer<>(*range), usage);
+  });
+}
+
+////
+
+void ClientWebGLContext::BufferSubData(GLenum target,
+                                       WebGLsizeiptr dstByteOffset,
+                                       const dom::ArrayBuffer& src) {
+  const FuncScope funcScope(*this, "bufferSubData");
+  src.ProcessFixedData([&](const Span<uint8_t>& aData) {
+    Run<RPROC(BufferSubData)>(target, dstByteOffset, RawBuffer<>(aData),
+                              /* unsynchronized */ false);
+  });
+}
+
+void ClientWebGLContext::BufferSubData(GLenum target,
+                                       WebGLsizeiptr dstByteOffset,
+                                       const dom::ArrayBufferView& src,
+                                       GLuint srcElemOffset,
+                                       GLuint srcElemCountOverride) {
+  const FuncScope funcScope(*this, "bufferSubData");
+  size_t elemSize = SizeOfViewElem(src);
+  src.ProcessFixedData([&](const Span<uint8_t>& aData) {
+    const auto& range =
+        ValidateArrayBufferView(aData, elemSize, srcElemOffset,
+                                srcElemCountOverride, LOCAL_GL_INVALID_VALUE);
+    if (!range) {
+      return;
+    }
+    Run<RPROC(BufferSubData)>(target, dstByteOffset, RawBuffer<>(*range),
+                              /* unsynchronized */ false);
+  });
+}
+
+void ClientWebGLContext::CopyBufferSubData(GLenum readTarget,
+                                           GLenum writeTarget,
+                                           GLintptr readOffset,
+                                           GLintptr writeOffset,
+                                           GLsizeiptr size) {
+  const FuncScope funcScope(*this, "copyBufferSubData");
+  if (!ValidateNonNegative("readOffset", readOffset) ||
+      !ValidateNonNegative("writeOffset", writeOffset) ||
+      !ValidateNonNegative("size", size)) {
+    return;
+  }
+  Run<RPROC(CopyBufferSubData)>(
+      readTarget, writeTarget, static_cast<uint64_t>(readOffset),
+      static_cast<uint64_t>(writeOffset), static_cast<uint64_t>(size));
+}
+
+// -------------------------- Framebuffer Objects --------------------------
+
+void ClientWebGLContext::BindFramebuffer(const GLenum target,
+                                         WebGLFramebufferJS* const fb) {
+  const FuncScope funcScope(*this, "bindFramebuffer");
+  if (IsContextLost()) return;
+  if (fb && !fb->ValidateUsable(*this, "fb")) return;
+
+  if (!IsFramebufferTarget(mIsWebGL2, target)) {
+    EnqueueError_ArgEnum("target", target);
+    return;
+  }
+
+  // -
+
+  auto& state = State();
+
+  switch (target) {
+    case LOCAL_GL_FRAMEBUFFER:
+      state.mBoundDrawFb = fb;
+      state.mBoundReadFb = fb;
+      break;
+
+    case LOCAL_GL_DRAW_FRAMEBUFFER:
+      state.mBoundDrawFb = fb;
+      break;
+    case LOCAL_GL_READ_FRAMEBUFFER:
+      state.mBoundReadFb = fb;
+      break;
+
+    default:
+      MOZ_CRASH();
+  }
+
+  // -
+
+  if (fb) {
+    fb->mHasBeenBound = true;
+  }
+
+  Run<RPROC(BindFramebuffer)>(target, fb ? fb->mId : 0);
+}
+
+// -
+
+void ClientWebGLContext::FramebufferTexture2D(GLenum target, GLenum attachSlot,
+                                              GLenum bindImageTarget,
+                                              WebGLTextureJS* const tex,
+                                              GLint mipLevel) const {
+  const FuncScope funcScope(*this, "framebufferTexture2D");
+  if (IsContextLost()) return;
+
+  const auto bindTexTarget = ImageToTexTarget(bindImageTarget);
+  uint32_t zLayer = 0;
+  switch (bindTexTarget) {
+    case LOCAL_GL_TEXTURE_2D:
+      break;
+    case LOCAL_GL_TEXTURE_CUBE_MAP:
+      zLayer = bindImageTarget - LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_X;
+      break;
+    default:
+      EnqueueError_ArgEnum("imageTarget", bindImageTarget);
+      return;
+  }
+
+  if (!mIsWebGL2 &&
+      !IsExtensionEnabled(WebGLExtensionID::OES_fbo_render_mipmap)) {
+    if (mipLevel != 0) {
+      EnqueueError(LOCAL_GL_INVALID_VALUE,
+                   "mipLevel != 0 requires OES_fbo_render_mipmap.");
+      return;
+    }
+  }
+
+  FramebufferAttach(target, attachSlot, bindImageTarget, nullptr, tex,
+                    static_cast<uint32_t>(mipLevel), zLayer, 0);
+}
+
+Maybe<webgl::ErrorInfo> CheckFramebufferAttach(const GLenum bindImageTarget,
+                                               const GLenum curTexTarget,
+                                               const uint32_t mipLevel,
+                                               const uint32_t zLayerBase,
+                                               const uint32_t zLayerCount,
+                                               const webgl::Limits& limits) {
+  if (!curTexTarget) {
+    return Some(
+        webgl::ErrorInfo{LOCAL_GL_INVALID_OPERATION,
+                         "`tex` not yet bound. Call bindTexture first."});
+  }
+
+  auto texTarget = curTexTarget;
+  if (bindImageTarget) {
+    // FramebufferTexture2D
+    const auto bindTexTarget = ImageToTexTarget(bindImageTarget);
+    if (curTexTarget != bindTexTarget) {
+      return Some(webgl::ErrorInfo{LOCAL_GL_INVALID_OPERATION,
+                                   "`tex` cannot be rebound to a new target."});
+    }
+
+    switch (bindTexTarget) {
+      case LOCAL_GL_TEXTURE_2D:
+      case LOCAL_GL_TEXTURE_CUBE_MAP:
+        break;
+      default:
+        return Some(webgl::ErrorInfo{LOCAL_GL_INVALID_ENUM,
+                                     "`tex` must have been bound to target "
+                                     "TEXTURE_2D or TEXTURE_CUBE_MAP."});
+    }
+    texTarget = bindTexTarget;
+  } else {
+    // FramebufferTextureLayer/Multiview
+    switch (curTexTarget) {
+      case LOCAL_GL_TEXTURE_2D_ARRAY:
+      case LOCAL_GL_TEXTURE_3D:
+        break;
+      default:
+        return Some(webgl::ErrorInfo{LOCAL_GL_INVALID_OPERATION,
+                                     "`tex` must have been bound to target "
+                                     "TEXTURE_2D_ARRAY or TEXTURE_3D."});
+    }
+  }
+  MOZ_ASSERT(texTarget);
+  uint32_t maxSize;
+  uint32_t maxZ;
+  switch (texTarget) {
+    case LOCAL_GL_TEXTURE_2D:
+      maxSize = limits.maxTex2dSize;
+      maxZ = 1;
+      break;
+    case LOCAL_GL_TEXTURE_CUBE_MAP:
+      maxSize = limits.maxTexCubeSize;
+      maxZ = 6;
+      break;
+    case LOCAL_GL_TEXTURE_2D_ARRAY:
+      maxSize = limits.maxTex2dSize;
+      maxZ = limits.maxTexArrayLayers;
+      break;
+    case LOCAL_GL_TEXTURE_3D:
+      maxSize = limits.maxTex3dSize;
+      maxZ = limits.maxTex3dSize;
+      break;
+    default:
+      MOZ_CRASH();
+  }
+  const auto maxMipLevel = FloorLog2(maxSize);
+  if (mipLevel > maxMipLevel) {
+    return Some(webgl::ErrorInfo{LOCAL_GL_INVALID_VALUE,
+                                 "`mipLevel` too large for texture target."});
+  }
+  const auto requiredZLayers = CheckedInt<uint32_t>(zLayerBase) + zLayerCount;
+  if (!requiredZLayers.isValid() || requiredZLayers.value() > maxZ) {
+    return Some(webgl::ErrorInfo{LOCAL_GL_INVALID_VALUE,
+                                 "`zLayer` too large for texture target."});
+  }
+
+  return {};
+}
+
+void ClientWebGLContext::FramebufferAttach(
+    const GLenum target, const GLenum attachSlot, const GLenum bindImageTarget,
+    WebGLRenderbufferJS* const rb, WebGLTextureJS* const tex,
+    const uint32_t mipLevel, const uint32_t zLayerBase,
+    const uint32_t numViewLayers) const {
+  if (rb && !rb->ValidateUsable(*this, "rb")) return;
+  if (tex && !tex->ValidateUsable(*this, "tex")) return;
+  const auto& state = State();
+  const auto& limits = Limits();
+
+  if (!IsFramebufferTarget(mIsWebGL2, target)) {
+    EnqueueError_ArgEnum("target", target);
+    return;
+  }
+  auto fb = state.mBoundDrawFb;
+  if (target == LOCAL_GL_READ_FRAMEBUFFER) {
+    fb = state.mBoundReadFb;
+  }
+  if (!fb) {
+    EnqueueError(LOCAL_GL_INVALID_OPERATION, "No framebuffer bound.");
+    return;
+  }
+
+  if (fb->mOpaque) {
+    EnqueueError(
+        LOCAL_GL_INVALID_OPERATION,
+        "An opaque framebuffer's attachments cannot be inspected or changed.");
+    return;
+  }
+
+  // -
+  // Multiview-specific validation skipped by Host.
+
+  if (tex && numViewLayers) {
+    if (tex->mTarget != LOCAL_GL_TEXTURE_2D_ARRAY) {
+      EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                   "`tex` must have been bound to target TEXTURE_2D_ARRAY.");
+      return;
+    }
+    if (numViewLayers > limits.maxMultiviewLayers) {
+      EnqueueError(LOCAL_GL_INVALID_VALUE,
+                   "`numViews` (%u) must be <= MAX_VIEWS (%u).", numViewLayers,
+                   limits.maxMultiviewLayers);
+      return;
+    }
+  }
+
+  // -
+
+  webgl::ObjectId id = 0;
+  if (tex) {
+    auto zLayerCount = numViewLayers;
+    if (!zLayerCount) {
+      zLayerCount = 1;
+    }
+    const auto err =
+        CheckFramebufferAttach(bindImageTarget, tex->mTarget, mipLevel,
+                               zLayerBase, zLayerCount, limits);
+    if (err) {
+      EnqueueError(err->type, "%s", err->info.c_str());
+      return;
+    }
+    id = tex->mId;
+  } else if (rb) {
+    if (!rb->mHasBeenBound) {
+      EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                   "`rb` has not yet been bound with BindRenderbuffer.");
+      return;
+    }
+    id = rb->mId;
+  }
+
+  // Ready!
+  // But DEPTH_STENCIL in webgl2 is actually two slots!
+
+  const auto fnAttachTo = [&](const GLenum actualAttachSlot) {
+    const auto slot = fb->GetAttachment(actualAttachSlot);
+    if (!slot) {
+      EnqueueError_ArgEnum("attachment", actualAttachSlot);
+      return;
+    }
+
+    slot->rb = rb;
+    slot->tex = tex;
+
+    Run<RPROC(FramebufferAttach)>(target, actualAttachSlot, bindImageTarget, id,
+                                  mipLevel, zLayerBase, numViewLayers);
+  };
+
+  if (mIsWebGL2 && attachSlot == LOCAL_GL_DEPTH_STENCIL_ATTACHMENT) {
+    fnAttachTo(LOCAL_GL_DEPTH_ATTACHMENT);
+    fnAttachTo(LOCAL_GL_STENCIL_ATTACHMENT);
+  } else {
+    fnAttachTo(attachSlot);
+  }
+
+  if (bindImageTarget) {
+    if (rb) {
+      rb->mHasBeenBound = true;
+    }
+    if (tex) {
+      tex->mTarget = ImageToTexTarget(bindImageTarget);
+    }
+  }
+}
+
+// -
+
+void ClientWebGLContext::BlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1,
+                                         GLint srcY1, GLint dstX0, GLint dstY0,
+                                         GLint dstX1, GLint dstY1,
+                                         GLbitfield mask, GLenum filter) {
+  Run<RPROC(BlitFramebuffer)>(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1,
+                              dstY1, mask, filter);
+
+  AfterDrawCall();
+}
+
+void ClientWebGLContext::InvalidateFramebuffer(
+    GLenum target, const dom::Sequence<GLenum>& attachments,
+    ErrorResult& unused) {
+  const auto range = MakeRange(attachments);
+  const auto& buffer = RawBufferView(range);
+  Run<RPROC(InvalidateFramebuffer)>(target, buffer);
+
+  // Never invalidate the backbuffer, so never needs AfterDrawCall.
+}
+
+void ClientWebGLContext::InvalidateSubFramebuffer(
+    GLenum target, const dom::Sequence<GLenum>& attachments, GLint x, GLint y,
+    GLsizei width, GLsizei height, ErrorResult& unused) {
+  const auto range = MakeRange(attachments);
+  const auto& buffer = RawBufferView(range);
+  Run<RPROC(InvalidateSubFramebuffer)>(target, buffer, x, y, width, height);
+
+  // Never invalidate the backbuffer, so never needs AfterDrawCall.
+}
+
+void ClientWebGLContext::ReadBuffer(GLenum mode) {
+  Run<RPROC(ReadBuffer)>(mode);
+}
+
+// ----------------------- Renderbuffer objects -----------------------
+
+void ClientWebGLContext::BindRenderbuffer(const GLenum target,
+                                          WebGLRenderbufferJS* const rb) {
+  const FuncScope funcScope(*this, "bindRenderbuffer");
+  if (IsContextLost()) return;
+  if (rb && !rb->ValidateUsable(*this, "rb")) return;
+  auto& state = State();
+
+  if (target != LOCAL_GL_RENDERBUFFER) {
+    EnqueueError_ArgEnum("target", target);
+    return;
+  }
+
+  state.mBoundRb = rb;
+  if (rb) {
+    rb->mHasBeenBound = true;
+  }
+}
+
+void ClientWebGLContext::RenderbufferStorageMultisample(GLenum target,
+                                                        GLsizei samples,
+                                                        GLenum internalFormat,
+                                                        GLsizei width,
+                                                        GLsizei height) const {
+  const FuncScope funcScope(*this, "renderbufferStorageMultisample");
+  if (IsContextLost()) return;
+
+  if (target != LOCAL_GL_RENDERBUFFER) {
+    EnqueueError_ArgEnum("target", target);
+    return;
+  }
+
+  const auto& state = State();
+
+  const auto& rb = state.mBoundRb;
+  if (!rb) {
+    EnqueueError(LOCAL_GL_INVALID_OPERATION, "No renderbuffer bound");
+    return;
+  }
+
+  if (!ValidateNonNegative("width", width) ||
+      !ValidateNonNegative("height", height) ||
+      !ValidateNonNegative("samples", samples)) {
+    return;
+  }
+
+  if (internalFormat == LOCAL_GL_DEPTH_STENCIL && samples > 0) {
+    // While our backend supports it trivially, the spec forbids it.
+    EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                 "WebGL 1's DEPTH_STENCIL format may not be multisampled. Use "
+                 "DEPTH24_STENCIL8 when `samples > 0`.");
+    return;
+  }
+
+  Run<RPROC(RenderbufferStorageMultisample)>(
+      rb->mId, static_cast<uint32_t>(samples), internalFormat,
+      static_cast<uint32_t>(width), static_cast<uint32_t>(height));
+}
+
+// --------------------------- Texture objects ---------------------------
+
+void ClientWebGLContext::ActiveTexture(const GLenum texUnitEnum) {
+  const FuncScope funcScope(*this, "activeTexture");
+  if (IsContextLost()) return;
+
+  if (texUnitEnum < LOCAL_GL_TEXTURE0) {
+    EnqueueError(LOCAL_GL_INVALID_VALUE,
+                 "`texture` (0x%04x) must be >= TEXTURE0 (0x%04x).",
+                 texUnitEnum, LOCAL_GL_TEXTURE0);
+    return;
+  }
+
+  const auto texUnit = texUnitEnum - LOCAL_GL_TEXTURE0;
+
+  auto& state = State();
+  if (texUnit >= state.mTexUnits.size()) {
+    EnqueueError(LOCAL_GL_INVALID_VALUE,
+                 "TEXTURE%u must be < MAX_COMBINED_TEXTURE_IMAGE_UNITS (%zu).",
+                 texUnit, state.mTexUnits.size());
+    return;
+  }
+
+  //-
+
+  state.mActiveTexUnit = texUnit;
+  Run<RPROC(ActiveTexture)>(texUnit);
+}
+
+static bool IsTexTarget(const GLenum texTarget, const bool webgl2) {
+  switch (texTarget) {
+    case LOCAL_GL_TEXTURE_2D:
+    case LOCAL_GL_TEXTURE_CUBE_MAP:
+      return true;
+
+    case LOCAL_GL_TEXTURE_2D_ARRAY:
+    case LOCAL_GL_TEXTURE_3D:
+      return webgl2;
+
+    default:
+      return false;
+  }
+}
+
+void ClientWebGLContext::BindTexture(const GLenum texTarget,
+                                     WebGLTextureJS* const tex) {
+  const FuncScope funcScope(*this, "bindTexture");
+  if (IsContextLost()) return;
+  if (tex && !tex->ValidateUsable(*this, "tex")) return;
+
+  if (!IsTexTarget(texTarget, mIsWebGL2)) {
+    EnqueueError_ArgEnum("texTarget", texTarget);
+    return;
+  }
+
+  if (tex && tex->mTarget) {
+    if (texTarget != tex->mTarget) {
+      EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                   "Texture previously bound to %s cannot be bound now to %s.",
+                   EnumString(tex->mTarget).c_str(),
+                   EnumString(texTarget).c_str());
+      return;
+    }
+  }
+
+  auto& state = State();
+  auto& texUnit = state.mTexUnits[state.mActiveTexUnit];
+  texUnit.texByTarget[texTarget] = tex;
+  if (tex) {
+    tex->mTarget = texTarget;
+  }
+
+  Run<RPROC(BindTexture)>(texTarget, tex ? tex->mId : 0);
+}
+
+void ClientWebGLContext::GenerateMipmap(GLenum texTarget) const {
+  Run<RPROC(GenerateMipmap)>(texTarget);
+}
+
+void ClientWebGLContext::GetTexParameter(
+    JSContext* cx, GLenum texTarget, GLenum pname,
+    JS::MutableHandle<JS::Value> retval) const {
+  retval.set(JS::NullValue());
+  const FuncScope funcScope(*this, "getTexParameter");
+  if (IsContextLost()) return;
+  auto& state = State();
+
+  auto& texUnit = state.mTexUnits[state.mActiveTexUnit];
+
+  const auto& tex = Find(texUnit.texByTarget, texTarget, nullptr);
+  if (!tex) {
+    if (!IsTexTarget(texTarget, mIsWebGL2)) {
+      EnqueueError_ArgEnum("texTarget", texTarget);
+    } else {
+      EnqueueError(LOCAL_GL_INVALID_OPERATION, "No texture bound to %s[%u].",
+                   EnumString(texTarget).c_str(), state.mActiveTexUnit);
+    }
+    return;
+  }
+
+  const auto maybe = [&]() {
+    const auto& inProcess = mNotLost->inProcess;
+    if (inProcess) {
+      return inProcess->GetTexParameter(tex->mId, pname);
+    }
+    const auto& child = mNotLost->outOfProcess;
+    child->FlushPendingCmds();
+    Maybe<double> ret;
+    if (!child->SendGetTexParameter(tex->mId, pname, &ret)) {
+      ret.reset();
+    }
+    return ret;
+  }();
+
+  if (maybe) {
+    switch (pname) {
+      case LOCAL_GL_TEXTURE_IMMUTABLE_FORMAT:
+        retval.set(JS::BooleanValue(*maybe));
+        break;
+
+      default:
+        retval.set(JS::NumberValue(*maybe));
+        break;
+    }
+  }
+}
+
+void ClientWebGLContext::TexParameterf(GLenum texTarget, GLenum pname,
+                                       GLfloat param) {
+  Run<RPROC(TexParameter_base)>(texTarget, pname, FloatOrInt(param));
+}
+
+void ClientWebGLContext::TexParameteri(GLenum texTarget, GLenum pname,
+                                       GLint param) {
+  Run<RPROC(TexParameter_base)>(texTarget, pname, FloatOrInt(param));
+}
+
+////////////////////////////////////
+
+static GLenum JSTypeMatchUnpackTypeError(GLenum unpackType,
+                                         js::Scalar::Type jsType) {
+  bool matches = false;
+  switch (unpackType) {
+    case LOCAL_GL_BYTE:
+      matches = (jsType == js::Scalar::Type::Int8);
+      break;
+
+    case LOCAL_GL_UNSIGNED_BYTE:
+      matches = (jsType == js::Scalar::Type::Uint8 ||
+                 jsType == js::Scalar::Type::Uint8Clamped);
+      break;
+
+    case LOCAL_GL_SHORT:
+      matches = (jsType == js::Scalar::Type::Int16);
+      break;
+
+    case LOCAL_GL_UNSIGNED_SHORT:
+    case LOCAL_GL_UNSIGNED_SHORT_4_4_4_4:
+    case LOCAL_GL_UNSIGNED_SHORT_5_5_5_1:
+    case LOCAL_GL_UNSIGNED_SHORT_5_6_5:
+    case LOCAL_GL_HALF_FLOAT:
+    case LOCAL_GL_HALF_FLOAT_OES:
+      matches = (jsType == js::Scalar::Type::Uint16);
+      break;
+
+    case LOCAL_GL_INT:
+      matches = (jsType == js::Scalar::Type::Int32);
+      break;
+
+    case LOCAL_GL_UNSIGNED_INT:
+    case LOCAL_GL_UNSIGNED_INT_2_10_10_10_REV:
+    case LOCAL_GL_UNSIGNED_INT_10F_11F_11F_REV:
+    case LOCAL_GL_UNSIGNED_INT_5_9_9_9_REV:
+    case LOCAL_GL_UNSIGNED_INT_24_8:
+      matches = (jsType == js::Scalar::Type::Uint32);
+      break;
+
+    case LOCAL_GL_FLOAT:
+      matches = (jsType == js::Scalar::Type::Float32);
+      break;
+
+    case LOCAL_GL_FLOAT_32_UNSIGNED_INT_24_8_REV:
+      matches = false;  // No valid jsType, but we allow uploads with null.
+      break;
+
+    default:
+      return LOCAL_GL_INVALID_ENUM;
+  }
+  if (!matches) return LOCAL_GL_INVALID_OPERATION;
+  return 0;
+}
+
+/////////////////////////////////////////////////
+
+static inline uvec2 CastUvec2(const ivec2& val) {
+  return {static_cast<uint32_t>(val.x), static_cast<uint32_t>(val.y)};
+}
+
+static inline uvec3 CastUvec3(const ivec3& val) {
+  return {static_cast<uint32_t>(val.x), static_cast<uint32_t>(val.y),
+          static_cast<uint32_t>(val.z)};
+}
+
+template <typename T>
+Range<T> SubRange(const Range<T>& full, const size_t offset,
+                  const size_t length) {
+  const auto newBegin = full.begin() + offset;
+  return Range<T>{newBegin, newBegin + length};
+}
+
+Maybe<Range<const uint8_t>> GetRangeFromData(const Span<uint8_t>& data,
+                                             size_t bytesPerElem,
+                                             GLuint elemOffset,
+                                             GLuint elemCountOverride) {
+  const auto byteRange = Range(data);  // In bytes.
+
+  auto elemCount = byteRange.length() / bytesPerElem;
+  if (elemOffset > elemCount) return {};
+  elemCount -= elemOffset;
+
+  if (elemCountOverride) {
+    if (elemCountOverride > elemCount) return {};
+    elemCount = elemCountOverride;
+  }
+  const auto subrange =
+      SubRange(byteRange, elemOffset * bytesPerElem, elemCount * bytesPerElem);
+  return Some(subrange);
+}
+
+// -
+
+static bool IsTexTargetForDims(const GLenum texTarget, const bool webgl2,
+                               const uint8_t funcDims) {
+  if (!IsTexTarget(texTarget, webgl2)) return false;
+  switch (texTarget) {
+    case LOCAL_GL_TEXTURE_2D:
+    case LOCAL_GL_TEXTURE_CUBE_MAP:
+      return funcDims == 2;
+
+    default:
+      return funcDims == 3;
+  }
+}
+
+void ClientWebGLContext::TexStorage(uint8_t funcDims, GLenum texTarget,
+                                    GLsizei levels, GLenum internalFormat,
+                                    const ivec3& size) const {
+  const FuncScope funcScope(*this, "texStorage[23]D");
+  if (IsContextLost()) return;
+  if (!IsTexTargetForDims(texTarget, mIsWebGL2, funcDims)) {
+    EnqueueError_ArgEnum("texTarget", texTarget);
+    return;
+  }
+  Run<RPROC(TexStorage)>(texTarget, static_cast<uint32_t>(levels),
+                         internalFormat, CastUvec3(size));
+}
+
+// -
+
+void webgl::TexUnpackBlobDesc::Shrink(const webgl::PackingInfo& pi) {
+  if (cpuData) {
+    if (!size.x || !size.y || !size.z) return;
+
+    const auto unpackRes = ExplicitUnpacking(pi, {});
+    if (!unpackRes.isOk()) {
+      return;
+    }
+    const auto& unpack = unpackRes.inspect();
+
+    const auto bytesUpperBound =
+        CheckedInt<size_t>(unpack.metrics.bytesPerRowStride) *
+        unpack.metrics.totalRows;
+    if (bytesUpperBound.isValid()) {
+      cpuData->Shrink(bytesUpperBound.value());
+    }
+  }
+}
+
+// -
+
+void ClientWebGLContext::TexImage(uint8_t funcDims, GLenum imageTarget,
+                                  GLint level, GLenum respecFormat,
+                                  const ivec3& offset,
+                                  const Maybe<ivec3>& isize, GLint border,
+                                  const webgl::PackingInfo& pi,
+                                  const TexImageSource& src) const {
+  const FuncScope funcScope(*this, "tex(Sub)Image[23]D");
+  if (IsContextLost()) return;
+  if (!IsTexTargetForDims(ImageToTexTarget(imageTarget), mIsWebGL2, funcDims)) {
+    EnqueueError_ArgEnum("imageTarget", imageTarget);
+    return;
+  }
+  if (border != 0) {
+    EnqueueError(LOCAL_GL_INVALID_VALUE, "`border` must be 0.");
+    return;
+  }
+
+  Maybe<uvec3> size;
+  if (isize) {
+    size = Some(CastUvec3(isize.value()));
+  }
+
+  // -
+
+  // -
+  bool isDataUpload = false;
+  auto desc = [&]() -> Maybe<webgl::TexUnpackBlobDesc> {
+    if (src.mPboOffset) {
+      isDataUpload = true;
+      const auto offset = static_cast<uint64_t>(*src.mPboOffset);
+      return Some(webgl::TexUnpackBlobDesc{imageTarget,
+                                           size.value(),
+                                           gfxAlphaType::NonPremult,
+                                           {},
+                                           Some(offset)});
+    }
+
+    if (src.mView) {
+      isDataUpload = true;
+      const auto& view = *src.mView;
+      const auto& jsType = view.Type();
+      const auto err = JSTypeMatchUnpackTypeError(pi.type, jsType);
+      switch (err) {
+        case LOCAL_GL_INVALID_ENUM:
+          EnqueueError_ArgEnum("unpackType", pi.type);
+          return {};
+        case LOCAL_GL_INVALID_OPERATION:
+          EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                       "ArrayBufferView type %s not compatible with `type` %s.",
+                       name(jsType), EnumString(pi.type).c_str());
+          return {};
+        default:
+          break;
+      }
+
+      return view.ProcessData(
+          [&](const Span<uint8_t>& aData,
+              JS::AutoCheckCannotGC&& nogc) -> Maybe<webgl::TexUnpackBlobDesc> {
+            const auto range = GetRangeFromData(aData, SizeOfViewElem(view),
+                                                src.mViewElemOffset,
+                                                src.mViewElemLengthOverride);
+            if (!range) {
+              nogc.reset();
+              EnqueueError(LOCAL_GL_INVALID_OPERATION, "`source` too small.");
+              return {};
+            }
+            return Some(webgl::TexUnpackBlobDesc{imageTarget,
+                                                 size.value(),
+                                                 gfxAlphaType::NonPremult,
+                                                 Some(RawBuffer<>{*range}),
+                                                 {}});
+          });
+    }
+
+    if (src.mImageBitmap) {
+      return webgl::FromImageBitmap(imageTarget, size, *(src.mImageBitmap),
+                                    src.mOut_error);
+    }
+
+    if (src.mImageData) {
+      const auto& imageData = *src.mImageData;
+      dom::Uint8ClampedArray scopedArr;
+      MOZ_RELEASE_ASSERT(scopedArr.Init(imageData.GetDataObject()));
+
+      return scopedArr.ProcessData(
+          [&](const Span<uint8_t>& aData,
+              JS::AutoCheckCannotGC&& nogc) -> Maybe<webgl::TexUnpackBlobDesc> {
+            const auto dataSize = aData.Length();
+            const auto data = aData.Elements();
+            if (dataSize == 0) {
+              nogc.reset();  // aData will not be used.
+              EnqueueError(
+                  LOCAL_GL_INVALID_VALUE,
+                  "ImageData.data.buffer is Detached. (Maybe you Transfered "
+                  "it to a Worker?");
+              return {};
+            }
+
+            // -
+
+            const gfx::IntSize imageSize(imageData.Width(), imageData.Height());
+            const auto sizeFromDims =
+                CheckedInt<size_t>(imageSize.width) * imageSize.height * 4;
+            MOZ_RELEASE_ASSERT(sizeFromDims.isValid() &&
+                               sizeFromDims.value() == dataSize);
+
+            const RefPtr<gfx::DataSourceSurface> surf =
+                gfx::Factory::CreateWrappingDataSourceSurface(
+                    data, imageSize.width * 4, imageSize,
+                    gfx::SurfaceFormat::R8G8B8A8);
+            MOZ_ASSERT(surf);
+
+            // -
+
+            const auto imageUSize = *uvec2::FromSize(imageSize);
+            const auto concreteSize =
+                size.valueOr(uvec3{imageUSize.x, imageUSize.y, 1});
+
+            // WhatWG "HTML Living Standard" (30 October 2015):
+            // "The getImageData(sx, sy, sw, sh) method [...] Pixels must be
+            // returned as non-premultiplied alpha values."
+            auto result =
+                Some(webgl::TexUnpackBlobDesc{imageTarget,
+                                              concreteSize,
+                                              gfxAlphaType::NonPremult,
+                                              {},
+                                              {},
+                                              Some(imageUSize),
+                                              nullptr,
+                                              {},
+                                              surf});
+            nogc.reset();  // Done with aData
+            return result;
+          });
+    }
+
+    if (src.mOffscreenCanvas) {
+      return webgl::FromOffscreenCanvas(
+          *this, imageTarget, size, *(src.mOffscreenCanvas), src.mOut_error);
+    }
+
+    if (src.mVideoFrame) {
+      return webgl::FromVideoFrame(*this, imageTarget, size, *(src.mVideoFrame),
+                                   src.mOut_error);
+    }
+
+    if (src.mDomElem) {
+      return webgl::FromDomElem(*this, imageTarget, size, *(src.mDomElem),
+                                src.mOut_error);
+    }
+
+    return Some(webgl::TexUnpackBlobDesc{
+        imageTarget, size.value(), gfxAlphaType::NonPremult, {}, {}});
+  }();
+  if (!desc) {
+    return;
+  }
+
+  // -
+
+  const auto& rawUnpacking = State().mPixelUnpackState;
+  {
+    auto defaultSubrectState = webgl::PixelPackingState{};
+    defaultSubrectState.alignmentInTypeElems =
+        rawUnpacking.alignmentInTypeElems;
+    const bool isSubrect = (rawUnpacking != defaultSubrectState);
+    if (isDataUpload && isSubrect) {
+      if (rawUnpacking.flipY || rawUnpacking.premultiplyAlpha) {
+        EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                     "Non-DOM-Element uploads with alpha-premult"
+                     " or y-flip do not support subrect selection.");
+        return;
+      }
+    }
+  }
+  desc->unpacking = rawUnpacking;
+
+  if (desc->structuredSrcSize) {
+    // WebGL 2 spec:
+    //   ### 5.35 Pixel store parameters for uploads from TexImageSource
+    //   UNPACK_ALIGNMENT and UNPACK_ROW_LENGTH are ignored.
+    const auto& elemSize = *desc->structuredSrcSize;
+    desc->unpacking.alignmentInTypeElems = 1;
+    desc->unpacking.rowLength = elemSize.x;
+  }
+  if (!desc->unpacking.rowLength) {
+    desc->unpacking.rowLength = desc->size.x;
+  }
+  if (!desc->unpacking.imageHeight) {
+    desc->unpacking.imageHeight = desc->size.y;
+  }
+
+  // -
+
+  // -
+
+  mozilla::ipc::Shmem* pShmem = nullptr;
+  // Image to release after WebGLContext::TexImage().
+  RefPtr<layers::Image> keepAliveImage;
+
+  if (desc->sd) {
+    const auto& sd = *(desc->sd);
+    const auto sdType = sd.type();
+    const auto& contextInfo = mNotLost->info;
+
+    const auto fallbackReason = [&]() -> Maybe<std::string> {
+      if (!respecFormat) {
+        return Some(std::string{
+            "Fast uploads not supported for TexSubImage. Use TexImage."});
+      }
+      auto fallbackReason = BlitPreventReason(
+          level, offset, respecFormat, pi, *desc, contextInfo.isRgb8Renderable);
+      if (fallbackReason) return fallbackReason;
+
+      const bool canUploadViaSd = contextInfo.uploadableSdTypes[sdType];
+      if (!canUploadViaSd) {
+        const nsPrintfCString msg(
+            "Fast uploads for resource type %i not implemented.", int(sdType));
+        return Some(ToString(msg));
+      }
+
+      switch (sdType) {
+        default:
+          break;
+        case layers::SurfaceDescriptor::TSurfaceDescriptorBuffer: {
+          const auto& sdb = sd.get_SurfaceDescriptorBuffer();
+          const auto& data = sdb.data();
+          if (data.type() == layers::MemoryOrShmem::TShmem) {
+            pShmem = &data.get_Shmem();
+          } else {
+            return Some(
+                std::string{"SurfaceDescriptorBuffer data is not Shmem."});
+          }
+        } break;
+        case layers::SurfaceDescriptor::TSurfaceDescriptorD3D10: {
+          const auto& sdD3D = sd.get_SurfaceDescriptorD3D10();
+          const auto& inProcess = mNotLost->inProcess;
+          MOZ_ASSERT(desc->image);
+          keepAliveImage = desc->image;
+
+          if (sdD3D.gpuProcessTextureId().isSome() && inProcess) {
+            return Some(
+                std::string{"gpuProcessTextureId works only in GPU process."});
+          }
+        } break;
+        case layers::SurfaceDescriptor::TSurfaceDescriptorGPUVideo: {
+          const auto& inProcess = mNotLost->inProcess;
+          MOZ_ASSERT(desc->image);
+          keepAliveImage = desc->image;
+          if (inProcess) {
+            return Some(std::string{
+                "SurfaceDescriptorGPUVideo works only in GPU process."});
+          }
+          const auto& sdv = sd.get_SurfaceDescriptorGPUVideo();
+          if (sdv.type() != layers::SurfaceDescriptorGPUVideo::
+                                TSurfaceDescriptorRemoteDecoder) {
+            return Some(std::string{
+                "SurfaceDescriptorGPUVideo does not contain RemoteDecoder."});
+          }
+          const auto& sdrd = sdv.get_SurfaceDescriptorRemoteDecoder();
+          const auto& subdesc = sdrd.subdesc();
+          if (subdesc.type() !=
+              layers::RemoteDecoderVideoSubDescriptor::Tnull_t) {
+            return Some(
+                std::string{"SurfaceDescriptorGPUVideo does not contain "
+                            "RemoteDecoder null subdesc."});
+          }
+        } break;
+      }
+
+      switch (respecFormat) {
+        case LOCAL_GL_SRGB:
+        case LOCAL_GL_SRGB8:
+        case LOCAL_GL_SRGB_ALPHA:
+        case LOCAL_GL_SRGB8_ALPHA8: {
+          const nsPrintfCString msg(
+              "srgb-encoded formats (like %s) are not supported.",
+              EnumString(respecFormat).c_str());
+          return Some(ToString(msg));
+        }
+      }
+
+      if (StaticPrefs::webgl_disable_DOM_blit_uploads()) {
+        return Some(std::string{"DOM blit uploads are disabled."});
+      }
+      return {};
+    }();
+
+    if (fallbackReason) {
+      EnqueuePerfWarning("Missed GPU-copy fast-path: %s",
+                         fallbackReason->c_str());
+
+      const auto& image = desc->image;
+      const RefPtr<gfx::SourceSurface> surf = image->GetAsSourceSurface();
+      if (surf) {
+        // WARNING: OSX can lose our MakeCurrent here.
+        desc->dataSurf = surf->GetDataSurface();
+      }
+      if (!desc->dataSurf) {
+        EnqueueError(LOCAL_GL_OUT_OF_MEMORY,
+                     "Failed to retrieve source bytes for CPU upload.");
+        return;
+      }
+      desc->sd = Nothing();
+    }
+  }
+  desc->image = nullptr;
+
+  desc->Shrink(pi);
+
+  // -
+
+  std::shared_ptr<webgl::RaiiShmem> tempShmem;
+
+  const bool doInlineUpload = !desc->sd;
+  // Why always de-inline SDs here?
+  // 1. This way we always send SDs down the same handling path, which
+  // should keep things from breaking if things flip between paths because of
+  // what we get handed by SurfaceFromElement etc.
+  // 2. We don't actually always grab strong-refs to the resources in the SDs,
+  // so we should try to use them sooner rather than later. Yes we should fix
+  // this, but for now let's give the SDs the best chance of lucking out, eh?
+  // :)
+  // 3. It means we don't need to write QueueParamTraits<SurfaceDescriptor>.
+  if (doInlineUpload) {
+    // We definitely want e.g. TexImage(PBO) here.
+    Run<RPROC(TexImage)>(static_cast<uint32_t>(level), respecFormat,
+                         CastUvec3(offset), pi, std::move(*desc));
+  } else {
+    // We can't handle shmems like SurfaceDescriptorBuffer inline, so use ipdl.
+    const auto& inProcess = mNotLost->inProcess;
+    if (inProcess) {
+      return inProcess->TexImage(static_cast<uint32_t>(level), respecFormat,
+                                 CastUvec3(offset), pi, *desc);
+    }
+    const auto& child = mNotLost->outOfProcess;
+    child->FlushPendingCmds();
+
+    // The shmem we're handling was only shared from RDD to Content, and
+    // immediately on Content receiving it, it was closed! RIP
+    // Eventually we'll be able to make shmems that can traverse multiple
+    // endpoints, but for now we need to make a new Content->WebGLParent shmem
+    // and memcpy into it. We don't use `desc` elsewhere, so just replace the
+    // Shmem buried within it with one that's valid for WebGLChild->Parent
+    // transport.
+    if (pShmem) {
+      MOZ_ASSERT(desc->sd);
+      const auto srcBytes = ShmemRange<uint8_t>(*pShmem);
+      tempShmem = std::make_shared<webgl::RaiiShmem>();
+
+      // We need Unsafe because we want to dictate when to destroy it from the
+      // client side.
+      *tempShmem = webgl::RaiiShmem::AllocUnsafe(child, srcBytes.length());
+      if (!*tempShmem) {
+        NS_WARNING("AllocShmem failed in TexImage");
+        return;
+      }
+      const auto dstBytes = ShmemRange<uint8_t>(tempShmem->Shmem());
+      Memcpy(&dstBytes, srcBytes.begin());
+
+      *pShmem = tempShmem->Shmem();
+      // Not Extract, because we free tempShmem manually below, after the remote
+      // side has finished executing SendTexImage.
+    }
+
+    (void)child->SendTexImage(static_cast<uint32_t>(level), respecFormat,
+                              CastUvec3(offset), pi, std::move(*desc));
+
+    if (tempShmem || keepAliveImage) {
+      const auto eventTarget = GetCurrentSerialEventTarget();
+      MOZ_ASSERT(eventTarget);
+      child->SendPing()->Then(eventTarget, __func__,
+                              [tempShmem, keepAliveImage]() {
+                                // Cleans up when (our copy of)
+                                // sendableShmem/image goes out of scope.
+                              });
+    }
+  }
+}
+
+// -
+
+void ClientWebGLContext::CompressedTexImage(bool sub, uint8_t funcDims,
+                                            GLenum imageTarget, GLint level,
+                                            GLenum format, const ivec3& offset,
+                                            const ivec3& isize, GLint border,
+                                            const TexImageSource& src,
+                                            GLsizei pboImageSize) const {
+  const FuncScope funcScope(*this, "compressedTex(Sub)Image[23]D");
+  if (IsContextLost()) return;
+  if (!IsTexTargetForDims(ImageToTexTarget(imageTarget), mIsWebGL2, funcDims)) {
+    EnqueueError_ArgEnum("imageTarget", imageTarget);
+    return;
+  }
+  if (border != 0) {
+    EnqueueError(LOCAL_GL_INVALID_VALUE, "`border` must be 0.");
+    return;
+  }
+
+  if (src.mView) {
+    src.mView->ProcessData([&](const Span<uint8_t>& aData,
+                               JS::AutoCheckCannotGC&& aNoGC) {
+      const auto range =
+          GetRangeFromData(aData, SizeOfViewElem(*src.mView),
+                           src.mViewElemOffset, src.mViewElemLengthOverride);
+      if (!range) {
+        aNoGC.reset();
+        EnqueueError(LOCAL_GL_INVALID_VALUE, "`source` too small.");
+        return;
+      }
+
+      // We don't need to shrink `range` because valid calls require
+      // `range` to match requirements exactly.
+
+      RunWithGCData<RPROC(CompressedTexImage)>(
+          std::move(aNoGC), sub, imageTarget, static_cast<uint32_t>(level),
+          format, CastUvec3(offset), CastUvec3(isize), RawBuffer<>{*range},
+          static_cast<uint32_t>(pboImageSize), Maybe<uint64_t>());
+      return;
+    });
+    return;
+  }
+  if (!src.mPboOffset) {
+    MOZ_CRASH("impossible");
+  }
+  if (!ValidateNonNegative("offset", *src.mPboOffset)) {
+    return;
+  }
+
+  Run<RPROC(CompressedTexImage)>(
+      sub, imageTarget, static_cast<uint32_t>(level), format, CastUvec3(offset),
+      CastUvec3(isize), RawBuffer<>(), static_cast<uint32_t>(pboImageSize),
+      Some(*src.mPboOffset));
+}
+
+void ClientWebGLContext::CopyTexImage(uint8_t funcDims, GLenum imageTarget,
+                                      GLint level, GLenum respecFormat,
+                                      const ivec3& dstOffset,
+                                      const ivec2& srcOffset, const ivec2& size,
+                                      GLint border) const {
+  const FuncScope funcScope(*this, "copy(Sub)Image[23]D");
+  if (IsContextLost()) return;
+  if (!IsTexTargetForDims(ImageToTexTarget(imageTarget), mIsWebGL2, funcDims)) {
+    EnqueueError_ArgEnum("imageTarget", imageTarget);
+    return;
+  }
+  if (border != 0) {
+    EnqueueError(LOCAL_GL_INVALID_VALUE, "`border` must be 0.");
+    return;
+  }
+  Run<RPROC(CopyTexImage)>(imageTarget, static_cast<uint32_t>(level),
+                           respecFormat, CastUvec3(dstOffset), srcOffset,
+                           CastUvec2(size));
+}
+
+// ------------------- Programs and shaders --------------------------------
+
+void ClientWebGLContext::UseProgram(WebGLProgramJS* const prog) {
+  const FuncScope funcScope(*this, "useProgram");
+  if (IsContextLost()) return;
+  if (prog && !prog->ValidateUsable(*this, "prog")) return;
+
+  auto& state = State();
+
+  if (state.mTfActiveAndNotPaused) {
+    EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                 "Transform feedback is active and not paused.");
+    return;
+  }
+
+  if (prog) {
+    const auto& res = GetLinkResult(*prog);
+    if (!res.success) {
+      EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                   "Program must be linked successfully.");
+      return;
+    }
+  }
+
+  // -
+
+  state.mCurrentProgram = prog;
+  state.mProgramKeepAlive = prog ? prog->mKeepAliveWeak.lock() : nullptr;
+  state.mActiveLinkResult = prog ? prog->mResult : nullptr;
+
+  Run<RPROC(UseProgram)>(prog ? prog->mId : 0);
+}
+
+void ClientWebGLContext::ValidateProgram(WebGLProgramJS& prog) const {
+  const FuncScope funcScope(*this, "validateProgram");
+  if (IsContextLost()) return;
+  if (!prog.ValidateUsable(*this, "prog")) return;
+
+  prog.mLastValidate = [&]() {
+    const auto& inProcess = mNotLost->inProcess;
+    if (inProcess) {
+      return inProcess->ValidateProgram(prog.mId);
+    }
+    const auto& child = mNotLost->outOfProcess;
+    child->FlushPendingCmds();
+    bool ret = {};
+    if (!child->SendValidateProgram(prog.mId, &ret)) {
+      ret = {};
+    }
+    return ret;
+  }();
+}
+
+// ------------------------ Uniforms and attributes ------------------------
+
+Maybe<double> ClientWebGLContext::GetVertexAttribPriv(const GLuint index,
+                                                      const GLenum pname) {
+  const auto& inProcess = mNotLost->inProcess;
+  if (inProcess) {
+    return inProcess->GetVertexAttrib(index, pname);
+  }
+  const auto& child = mNotLost->outOfProcess;
+  child->FlushPendingCmds();
+  Maybe<double> ret;
+  if (!child->SendGetVertexAttrib(index, pname, &ret)) {
+    ret.reset();
+  }
+  return ret;
+}
+
+void ClientWebGLContext::GetVertexAttrib(JSContext* cx, GLuint index,
+                                         GLenum pname,
+                                         JS::MutableHandle<JS::Value> retval,
+                                         ErrorResult& rv) {
+  retval.set(JS::NullValue());
+  const FuncScope funcScope(*this, "getVertexAttrib");
+  if (IsContextLost()) return;
+  const auto& state = State();
+
+  const auto& genericAttribs = state.mGenericVertexAttribs;
+  if (index >= genericAttribs.size()) {
+    EnqueueError(LOCAL_GL_INVALID_VALUE, "`index` (%u) >= MAX_VERTEX_ATTRIBS",
+                 index);
+    return;
+  }
+
+  switch (pname) {
+    case LOCAL_GL_CURRENT_VERTEX_ATTRIB: {
+      const auto& attrib = genericAttribs[index];
+      switch (attrib.type) {
+        case webgl::AttribBaseType::Float: {
+          const auto ptr = reinterpret_cast<const float*>(attrib.data.data());
+          retval.setObjectOrNull(
+              dom::Float32Array::Create(cx, this, Span(ptr, 4), rv));
+          break;
+        }
+        case webgl::AttribBaseType::Int: {
+          const auto ptr = reinterpret_cast<const int32_t*>(attrib.data.data());
+          retval.setObjectOrNull(
+              dom::Int32Array::Create(cx, this, Span(ptr, 4), rv));
+          break;
+        }
+        case webgl::AttribBaseType::Uint: {
+          const auto ptr =
+              reinterpret_cast<const uint32_t*>(attrib.data.data());
+          retval.setObjectOrNull(
+              dom::Uint32Array::Create(cx, this, Span(ptr, 4), rv));
+          break;
+        }
+        case webgl::AttribBaseType::Boolean:
+          MOZ_CRASH("impossible");
+      }
+
+      return;
+    }
+
+    case LOCAL_GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: {
+      const auto& buffers = state.mBoundVao->mAttribBuffers;
+      const auto& buffer = buffers[index];
+      (void)ToJSValueOrNull(cx, buffer, retval);
+      return;
+    }
+
+    case LOCAL_GL_VERTEX_ATTRIB_ARRAY_POINTER:
+      // Disallowed from JS, but allowed in Host.
+      EnqueueError_ArgEnum("pname", pname);
+      return;
+
+    default:
+      break;
+  }
+
+  const auto maybe = GetVertexAttribPriv(index, pname);
+  if (maybe) {
+    switch (pname) {
+      case LOCAL_GL_VERTEX_ATTRIB_ARRAY_ENABLED:
+      case LOCAL_GL_VERTEX_ATTRIB_ARRAY_NORMALIZED:
+      case LOCAL_GL_VERTEX_ATTRIB_ARRAY_INTEGER:
+        retval.set(JS::BooleanValue(*maybe));
+        break;
+
+      default:
+        retval.set(JS::NumberValue(*maybe));
+        break;
+    }
+  }
+}
+
+void ClientWebGLContext::UniformData(const GLenum funcElemType,
+                                     const WebGLUniformLocationJS* const loc,
+                                     bool transpose,
+                                     const Range<const uint8_t>& bytes,
+                                     JS::AutoCheckCannotGC&& nogc,
+                                     GLuint elemOffset,
+                                     GLuint elemCountOverride) const {
+  // FuncScope::~FuncScope() can GC in a failure case, so all `return`
+  // statements need to `nogc.reset()` up until the `nogc` is consumed by
+  // `RunWithGCData`.
+  const FuncScope funcScope(*this, "uniform setter");
+  if (IsContextLost()) {
+    nogc.reset();
+    return;
+  }
+
+  const auto& activeLinkResult = GetActiveLinkResult();
+  if (!activeLinkResult) {
+    nogc.reset();
+    EnqueueError(LOCAL_GL_INVALID_OPERATION, "No active linked Program.");
+    return;
+  }
+
+  // -
+
+  auto availCount = bytes.length() / sizeof(float);
+  if (elemOffset > availCount) {
+    nogc.reset();
+    EnqueueError(LOCAL_GL_INVALID_VALUE, "`elemOffset` too large for `data`.");
+    return;
+  }
+  availCount -= elemOffset;
+  if (elemCountOverride) {
+    if (elemCountOverride > availCount) {
+      nogc.reset();
+      EnqueueError(LOCAL_GL_INVALID_VALUE,
+                   "`elemCountOverride` too large for `data`.");
+      return;
+    }
+    availCount = elemCountOverride;
+  }
+
+  // -
+
+  const auto channels = ElemTypeComponents(funcElemType);
+  if (!availCount || availCount % channels != 0) {
+    nogc.reset();
+    EnqueueError(LOCAL_GL_INVALID_VALUE,
+                 "`values` length (%u) must be a positive "
+                 "integer multiple of size of %s.",
+                 availCount, EnumString(funcElemType).c_str());
+    return;
+  }
+
+  // -
+
+  uint32_t locId = -1;
+  if (MOZ_LIKELY(loc)) {
+    locId = loc->mLocation;
+    if (!loc->ValidateUsable(*this, "location")) {
+      nogc.reset();
+      return;
+    }
+
+    // -
+
+    const auto& reqLinkInfo = loc->mParent.lock();
+    if (reqLinkInfo.get() != activeLinkResult) {
+      nogc.reset();
+      EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                   "UniformLocation is not from the current active Program.");
+      return;
+    }
+
+    // -
+
+    bool funcMatchesLocation = false;
+    for (const auto allowed : loc->mValidUploadElemTypes) {
+      funcMatchesLocation |= (funcElemType == allowed);
+    }
+    if (MOZ_UNLIKELY(!funcMatchesLocation)) {
+      std::string validSetters;
+      for (const auto allowed : loc->mValidUploadElemTypes) {
+        validSetters += EnumString(allowed);
+        validSetters += '/';
+      }
+      validSetters.pop_back();  // Cheekily discard the extra trailing '/'.
+
+      nogc.reset();
+      EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                   "Uniform's `type` requires uniform setter of type %s.",
+                   validSetters.c_str());
+      return;
+    }
+  }
+
+  // -
+
+  const auto begin =
+      reinterpret_cast<const webgl::UniformDataVal*>(bytes.begin().get()) +
+      elemOffset;
+  const auto range = Range{begin, availCount};
+  RunWithGCData<RPROC(UniformData)>(std::move(nogc), locId, transpose,
+                                    RawBuffer{range});
+}
+
+// -
+
+void ClientWebGLContext::BindVertexArray(WebGLVertexArrayJS* const vao) {
+  const FuncScope funcScope(*this, "bindVertexArray");
+  if (IsContextLost()) return;
+  if (vao && !vao->ValidateUsable(*this, "vao")) return;
+  auto& state = State();
+
+  if (vao) {
+    vao->mHasBeenBound = true;
+    state.mBoundVao = vao;
+  } else {
+    state.mBoundVao = state.mDefaultVao;
+  }
+
+  Run<RPROC(BindVertexArray)>(vao ? vao->mId : 0);
+}
+
+void ClientWebGLContext::EnableVertexAttribArray(GLuint index) {
+  Run<RPROC(EnableVertexAttribArray)>(index);
+}
+
+void ClientWebGLContext::DisableVertexAttribArray(GLuint index) {
+  Run<RPROC(DisableVertexAttribArray)>(index);
+}
+
+WebGLsizeiptr ClientWebGLContext::GetVertexAttribOffset(GLuint index,
+                                                        GLenum pname) {
+  const FuncScope funcScope(*this, "getVertexAttribOffset");
+  if (IsContextLost()) return 0;
+
+  if (pname != LOCAL_GL_VERTEX_ATTRIB_ARRAY_POINTER) {
+    EnqueueError_ArgEnum("pname", pname);
+    return 0;
+  }
+
+  const auto maybe = GetVertexAttribPriv(index, pname);
+  if (!maybe) return 0;
+  return *maybe;
+}
+
+void ClientWebGLContext::VertexAttrib4Tv(GLuint index, webgl::AttribBaseType t,
+                                         const Range<const uint8_t>& src) {
+  const FuncScope funcScope(*this, "vertexAttrib[1234]u?[fi]{v}");
+  if (IsContextLost()) return;
+  auto& state = State();
+
+  if (src.length() / sizeof(float) < 4) {
+    EnqueueError(LOCAL_GL_INVALID_VALUE, "Array must have >=4 elements.");
+    return;
+  }
+
+  auto& list = state.mGenericVertexAttribs;
+  if (index >= list.size()) {
+    EnqueueError(LOCAL_GL_INVALID_VALUE,
+                 "`index` must be < MAX_VERTEX_ATTRIBS.");
+    return;
+  }
+
+  auto& attrib = list[index];
+  attrib.type = t;
+  memcpy(attrib.data.data(), src.begin().get(), attrib.data.size());
+
+  Run<RPROC(VertexAttrib4T)>(index, attrib);
+}
+
+// -
+
+void ClientWebGLContext::VertexAttribDivisor(GLuint index, GLuint divisor) {
+  Run<RPROC(VertexAttribDivisor)>(index, divisor);
+}
+
+// -
+
+void ClientWebGLContext::VertexAttribPointerImpl(bool isFuncInt, GLuint index,
+                                                 GLint rawChannels, GLenum type,
+                                                 bool normalized,
+                                                 GLsizei rawByteStrideOrZero,
+                                                 WebGLintptr rawByteOffset) {
+  const FuncScope funcScope(*this, "vertexAttribI?Pointer");
+  if (IsContextLost()) return;
+  auto& state = State();
+
+  const auto channels = MaybeAs<uint8_t>(rawChannels);
+  if (!channels) {
+    EnqueueError(LOCAL_GL_INVALID_VALUE,
+                 "Channel count `size` must be within [1,4].");
+    return;
+  }
+
+  const auto byteStrideOrZero = MaybeAs<uint8_t>(rawByteStrideOrZero);
+  if (!byteStrideOrZero) {
+    EnqueueError(LOCAL_GL_INVALID_VALUE, "`stride` must be within [0,255].");
+    return;
+  }
+
+  if (!ValidateNonNegative("byteOffset", rawByteOffset)) return;
+  const auto byteOffset = static_cast<uint64_t>(rawByteOffset);
+
+  // -
+
+  const webgl::VertAttribPointerDesc desc{
+      isFuncInt, *channels, normalized, *byteStrideOrZero, type, byteOffset};
+
+  const auto res = CheckVertexAttribPointer(mIsWebGL2, desc);
+  if (res.isErr()) {
+    const auto& err = res.inspectErr();
+    EnqueueError(err.type, "%s", err.info.c_str());
+    return;
+  }
+
+  auto& list = state.mBoundVao->mAttribBuffers;
+  if (index >= list.size()) {
+    EnqueueError(LOCAL_GL_INVALID_VALUE,
+                 "`index` (%u) must be < MAX_VERTEX_ATTRIBS.", index);
+    return;
+  }
+
+  const auto buffer = state.mBoundBufferByTarget[LOCAL_GL_ARRAY_BUFFER];
+  if (!buffer && byteOffset) {
+    return EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                        "If ARRAY_BUFFER is null, byteOffset must be zero.");
+  }
+
+  Run<RPROC(VertexAttribPointer)>(index, desc);
+
+  list[index] = buffer;
+}
+
+// -------------------------------- Drawing -------------------------------
+
+void ClientWebGLContext::DrawArraysInstanced(GLenum mode, GLint first,
+                                             GLsizei count, GLsizei primcount) {
+  Run<RPROC(DrawArraysInstanced)>(mode, first, count, primcount);
+  AfterDrawCall();
+}
+
+void ClientWebGLContext::DrawElementsInstanced(GLenum mode, GLsizei count,
+                                               GLenum type, WebGLintptr offset,
+                                               GLsizei primcount) {
+  Run<RPROC(DrawElementsInstanced)>(mode, count, type, offset, primcount);
+  AfterDrawCall();
+}
+
+// ------------------------------ Readback -------------------------------
+void ClientWebGLContext::ReadPixels(GLint x, GLint y, GLsizei width,
+                                    GLsizei height, GLenum format, GLenum type,
+                                    WebGLsizeiptr offset,
+                                    dom::CallerType aCallerType,
+                                    ErrorResult& out_error) const {
+  const FuncScope funcScope(*this, "readPixels");
+  if (!ReadPixels_SharedPrecheck(aCallerType, out_error)) return;
+  const auto& state = State();
+  if (!ValidateNonNegative("width", width)) return;
+  if (!ValidateNonNegative("height", height)) return;
+  if (!ValidateNonNegative("offset", offset)) return;
+
+  const auto desc = webgl::ReadPixelsDesc{{x, y},
+                                          *uvec2::From(width, height),
+                                          {format, type},
+                                          state.mPixelPackState};
+  Run<RPROC(ReadPixelsPbo)>(desc, static_cast<uint64_t>(offset));
+}
+
+void ClientWebGLContext::ReadPixels(GLint x, GLint y, GLsizei width,
+                                    GLsizei height, GLenum format, GLenum type,
+                                    const dom::ArrayBufferView& dstData,
+                                    GLuint dstElemOffset,
+                                    dom::CallerType aCallerType,
+                                    ErrorResult& out_error) const {
+  const FuncScope funcScope(*this, "readPixels");
+  if (!ReadPixels_SharedPrecheck(aCallerType, out_error)) return;
+  const auto& state = State();
+  if (!ValidateNonNegative("width", width)) return;
+  if (!ValidateNonNegative("height", height)) return;
+
+  ////
+
+  js::Scalar::Type reqScalarType;
+  if (!GetJSScalarFromGLType(type, &reqScalarType)) {
+    nsCString name;
+    WebGLContext::EnumName(type, &name);
+    EnqueueError(LOCAL_GL_INVALID_ENUM, "type: invalid enum value %s",
+                 name.BeginReading());
+    return;
+  }
+
+  auto viewElemType = dstData.Type();
+  if (viewElemType == js::Scalar::Uint8Clamped) {
+    viewElemType = js::Scalar::Uint8;
+  }
+  if (viewElemType != reqScalarType) {
+    EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                 "`pixels` type does not match `type`.");
+    return;
+  }
+
+  size_t elemSize = SizeOfViewElem(dstData);
+  dstData.ProcessFixedData([&](const Span<uint8_t>& aData) {
+    const auto& range = ValidateArrayBufferView(aData, elemSize, dstElemOffset,
+                                                0, LOCAL_GL_INVALID_VALUE);
+    if (!range) {
+      return;
+    }
+
+    const auto desc = webgl::ReadPixelsDesc{{x, y},
+                                            *uvec2::From(width, height),
+                                            {format, type},
+                                            state.mPixelPackState};
+    (void)DoReadPixels(desc, *range);
+  });
+}
+
+bool ClientWebGLContext::DoReadPixels(const webgl::ReadPixelsDesc& desc,
+                                      const Range<uint8_t> dest) const {
+  const auto notLost =
+      mNotLost;  // Hold a strong-ref to prevent LoseContext=>UAF.
+  if (!notLost) return false;
+  const auto& inProcess = notLost->inProcess;
+  if (inProcess) {
+    inProcess->ReadPixelsInto(desc, dest);
+    return true;
+  }
+  const auto& child = notLost->outOfProcess;
+  child->FlushPendingCmds();
+  webgl::ReadPixelsResultIpc res = {};
+  if (!child->SendReadPixels(desc, dest.length(), &res)) {
+    res = {};
+  }
+  if (!res.byteStride || !res.shmem) return false;
+  const auto& byteStride = res.byteStride;
+  const auto& subrect = res.subrect;
+  const webgl::RaiiShmem shmem{child, res.shmem.ref()};
+  if (!shmem) {
+    EnqueueError(LOCAL_GL_OUT_OF_MEMORY, "Failed to map in back buffer.");
+    return false;
+  }
+
+  const auto& shmemBytes = shmem.ByteRange();
+
+  const auto pii = webgl::PackingInfoInfo::For(desc.pi);
+  if (!pii) {
+    gfxCriticalError() << "ReadPixels: Bad " << desc.pi;
+    return false;
+  }
+  const auto bpp = pii->BytesPerPixel();
+
+  const auto& packing = desc.packState;
+  auto packRect = *uvec2::From(subrect.x, subrect.y);
+  packRect.x += packing.skipPixels;
+  packRect.y += packing.skipRows;
+
+  const auto xByteSize = bpp * static_cast<uint32_t>(subrect.width);
+  const ptrdiff_t byteOffset = packRect.y * byteStride + packRect.x * bpp;
+
+  auto srcItr = shmemBytes.begin() + byteOffset;
+  auto destItr = dest.begin() + byteOffset;
+
+  for (const auto i : IntegerRange(subrect.height)) {
+    if (i) {
+      // Don't trigger an assert on the last loop by pushing a RangedPtr past
+      // its bounds.
+      srcItr += byteStride;
+      destItr += byteStride;
+      MOZ_RELEASE_ASSERT(srcItr + xByteSize <= shmemBytes.end());
+      MOZ_RELEASE_ASSERT(destItr + xByteSize <= dest.end());
+    }
+    Memcpy(destItr, srcItr, xByteSize);
+  }
+
+  return true;
+}
+
+bool ClientWebGLContext::ReadPixels_SharedPrecheck(
+    dom::CallerType aCallerType, ErrorResult& out_error) const {
+  if (IsContextLost()) return false;
+
+  if (mCanvasElement && mCanvasElement->IsWriteOnly() &&
+      aCallerType != dom::CallerType::System) {
+    JsWarning("readPixels: Not allowed");
+    out_error.Throw(NS_ERROR_DOM_SECURITY_ERR);
+    return false;
+  }
+
+  return true;
+}
+
+// --------------------------------- GL Query ---------------------------------
+
+static inline GLenum QuerySlotTarget(const GLenum specificTarget) {
+  if (specificTarget == LOCAL_GL_ANY_SAMPLES_PASSED_CONSERVATIVE) {
+    return LOCAL_GL_ANY_SAMPLES_PASSED;
+  }
+  return specificTarget;
+}
+
+void ClientWebGLContext::GetQuery(JSContext* cx, GLenum specificTarget,
+                                  GLenum pname,
+                                  JS::MutableHandle<JS::Value> retval) const {
+  retval.set(JS::NullValue());
+  const FuncScope funcScope(*this, "getQuery");
+  if (IsContextLost()) return;
+  const auto& limits = Limits();
+  auto& state = State();
+
+  if (IsExtensionEnabled(WebGLExtensionID::EXT_disjoint_timer_query)) {
+    if (pname == LOCAL_GL_QUERY_COUNTER_BITS) {
+      switch (specificTarget) {
+        case LOCAL_GL_TIME_ELAPSED_EXT:
+          retval.set(JS::NumberValue(limits.queryCounterBitsTimeElapsed));
+          return;
+
+        case LOCAL_GL_TIMESTAMP_EXT:
+          retval.set(JS::NumberValue(limits.queryCounterBitsTimestamp));
+          return;
+
+        default:
+          EnqueueError_ArgEnum("target", specificTarget);
+          return;
+      }
+    }
+  }
+
+  if (pname != LOCAL_GL_CURRENT_QUERY) {
+    EnqueueError_ArgEnum("pname", pname);
+    return;
+  }
+
+  const auto slotTarget = QuerySlotTarget(specificTarget);
+  const auto& slot = MaybeFind(state.mCurrentQueryByTarget, slotTarget);
+  if (!slot) {
+    EnqueueError_ArgEnum("target", specificTarget);
+    return;
+  }
+
+  auto query = *slot;
+  if (query && query->mTarget != specificTarget) {
+    query = nullptr;
+  }
+
+  (void)ToJSValueOrNull(cx, query, retval);
+}
+
+void ClientWebGLContext::GetQueryParameter(
+    JSContext*, WebGLQueryJS& query, const GLenum pname,
+    JS::MutableHandle<JS::Value> retval) const {
+  retval.set(JS::NullValue());
+  const FuncScope funcScope(*this, "getQueryParameter");
+  if (IsContextLost()) return;
+  if (!query.ValidateUsable(*this, "query")) return;
+
+  auto maybe = [&]() {
+    const auto& inProcess = mNotLost->inProcess;
+    if (inProcess) {
+      return inProcess->GetQueryParameter(query.mId, pname);
+    }
+    const auto& child = mNotLost->outOfProcess;
+    child->FlushPendingCmds();
+    Maybe<double> ret;
+    if (!child->SendGetQueryParameter(query.mId, pname, &ret)) {
+      ret.reset();
+    }
+    return ret;
+  }();
+  if (!maybe) return;
+
+  // We must usually wait for an event loop before the query can be available.
+  const bool canBeAvailable =
+      (query.mCanBeAvailable || StaticPrefs::webgl_allow_immediate_queries());
+  if (!canBeAvailable) {
+    if (pname != LOCAL_GL_QUERY_RESULT_AVAILABLE) {
+      return;
+    }
+    maybe = Some(0.0);
+  }
+
+  switch (pname) {
+    case LOCAL_GL_QUERY_RESULT_AVAILABLE:
+      retval.set(JS::BooleanValue(*maybe));
+      break;
+
+    default:
+      retval.set(JS::NumberValue(*maybe));
+      break;
+  }
+}
+
+void ClientWebGLContext::BeginQuery(const GLenum specificTarget,
+                                    WebGLQueryJS& query) {
+  const FuncScope funcScope(*this, "beginQuery");
+  if (IsContextLost()) return;
+  if (!query.ValidateUsable(*this, "query")) return;
+  auto& state = State();
+
+  const auto slotTarget = QuerySlotTarget(specificTarget);
+  const auto& slot = MaybeFind(state.mCurrentQueryByTarget, slotTarget);
+  if (!slot) {
+    EnqueueError_ArgEnum("target", specificTarget);
+    return;
+  }
+
+  if (*slot) {
+    auto enumStr = EnumString(slotTarget);
+    if (slotTarget == LOCAL_GL_ANY_SAMPLES_PASSED) {
+      enumStr += "/ANY_SAMPLES_PASSED_CONSERVATIVE";
+    }
+    EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                 "A Query is already active for %s.", enumStr.c_str());
+    return;
+  }
+
+  if (query.mTarget && query.mTarget != specificTarget) {
+    EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                 "`query` cannot be changed to a different target.");
+    return;
+  }
+
+  *slot = &query;
+  query.mTarget = specificTarget;
+
+  Run<RPROC(BeginQuery)>(specificTarget, query.mId);
+}
+
+void ClientWebGLContext::EndQuery(const GLenum specificTarget) {
+  const FuncScope funcScope(*this, "endQuery");
+  if (IsContextLost()) return;
+  auto& state = State();
+
+  const auto slotTarget = QuerySlotTarget(specificTarget);
+  const auto& maybeSlot = MaybeFind(state.mCurrentQueryByTarget, slotTarget);
+  if (!maybeSlot) {
+    EnqueueError_ArgEnum("target", specificTarget);
+    return;
+  }
+  auto& slot = *maybeSlot;
+  if (!slot || slot->mTarget != specificTarget) {
+    EnqueueError(LOCAL_GL_INVALID_OPERATION, "No Query is active for %s.",
+                 EnumString(specificTarget).c_str());
+    return;
+  }
+  const auto query = slot;
+  slot = nullptr;
+
+  Run<RPROC(EndQuery)>(specificTarget);
+
+  auto& availRunnable = EnsureAvailabilityRunnable();
+  availRunnable.mQueries.push_back(query.get());
+  query->mCanBeAvailable = false;
+}
+
+void ClientWebGLContext::QueryCounter(WebGLQueryJS& query,
+                                      const GLenum target) const {
+  const FuncScope funcScope(*this, "queryCounter");
+  if (IsContextLost()) return;
+  if (!query.ValidateUsable(*this, "query")) return;
+
+  if (target != LOCAL_GL_TIMESTAMP) {
+    EnqueueError(LOCAL_GL_INVALID_ENUM, "`target` must be TIMESTAMP.");
+    return;
+  }
+
+  if (query.mTarget && query.mTarget != target) {
+    EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                 "`query` cannot be changed to a different target.");
+    return;
+  }
+  query.mTarget = target;
+
+  Run<RPROC(QueryCounter)>(query.mId);
+
+  auto& availRunnable = EnsureAvailabilityRunnable();
+  availRunnable.mQueries.push_back(&query);
+  query.mCanBeAvailable = false;
+}
+
+// -------------------------------- Sampler -------------------------------
+void ClientWebGLContext::GetSamplerParameter(
+    JSContext* cx, const WebGLSamplerJS& sampler, const GLenum pname,
+    JS::MutableHandle<JS::Value> retval) const {
+  retval.set(JS::NullValue());
+  const FuncScope funcScope(*this, "getSamplerParameter");
+  if (IsContextLost()) return;
+  if (!sampler.ValidateUsable(*this, "sampler")) return;
+
+  const auto maybe = [&]() {
+    const auto& inProcess = mNotLost->inProcess;
+    if (inProcess) {
+      return inProcess->GetSamplerParameter(sampler.mId, pname);
+    }
+    const auto& child = mNotLost->outOfProcess;
+    child->FlushPendingCmds();
+    Maybe<double> ret;
+    if (!child->SendGetSamplerParameter(sampler.mId, pname, &ret)) {
+      ret.reset();
+    }
+    return ret;
+  }();
+  if (maybe) {
+    retval.set(JS::NumberValue(*maybe));
+  }
+}
+
+void ClientWebGLContext::BindSampler(const GLuint unit,
+                                     WebGLSamplerJS* const sampler) {
+  const FuncScope funcScope(*this, "bindSampler");
+  if (IsContextLost()) return;
+  if (sampler && !sampler->ValidateUsable(*this, "sampler")) return;
+  auto& state = State();
+
+  auto& texUnits = state.mTexUnits;
+  if (unit >= texUnits.size()) {
+    EnqueueError(LOCAL_GL_INVALID_VALUE, "`unit` (%u) larger than %zu.", unit,
+                 texUnits.size());
+    return;
+  }
+
+  // -
+
+  texUnits[unit].sampler = sampler;
+
+  Run<RPROC(BindSampler)>(unit, sampler ? sampler->mId : 0);
+}
+
+void ClientWebGLContext::SamplerParameteri(WebGLSamplerJS& sampler,
+                                           const GLenum pname,
+                                           const GLint param) const {
+  const FuncScope funcScope(*this, "samplerParameteri");
+  if (IsContextLost()) return;
+  if (!sampler.ValidateUsable(*this, "sampler")) return;
+
+  Run<RPROC(SamplerParameteri)>(sampler.mId, pname, param);
+}
+
+void ClientWebGLContext::SamplerParameterf(WebGLSamplerJS& sampler,
+                                           const GLenum pname,
+                                           const GLfloat param) const {
+  const FuncScope funcScope(*this, "samplerParameterf");
+  if (IsContextLost()) return;
+  if (!sampler.ValidateUsable(*this, "sampler")) return;
+
+  Run<RPROC(SamplerParameterf)>(sampler.mId, pname, param);
+}
+
+// ------------------------------- GL Sync ---------------------------------
+
+void ClientWebGLContext::GetSyncParameter(
+    JSContext* const cx, WebGLSyncJS& sync, const GLenum pname,
+    JS::MutableHandle<JS::Value> retval) const {
+  retval.set(JS::NullValue());
+  const FuncScope funcScope(*this, "getSyncParameter");
+  if (IsContextLost()) return;
+  if (!sync.ValidateUsable(*this, "sync")) return;
+
+  retval.set([&]() -> JS::Value {
+    switch (pname) {
+      case LOCAL_GL_OBJECT_TYPE:
+        return JS::NumberValue(LOCAL_GL_SYNC_FENCE);
+      case LOCAL_GL_SYNC_CONDITION:
+        return JS::NumberValue(LOCAL_GL_SYNC_GPU_COMMANDS_COMPLETE);
+      case LOCAL_GL_SYNC_FLAGS:
+        return JS::NumberValue(0);
+      case LOCAL_GL_SYNC_STATUS: {
+        if (!sync.mSignaled) {
+          const auto res = ClientWaitSync(sync, 0, 0);
+          sync.mSignaled = (res == LOCAL_GL_ALREADY_SIGNALED ||
+                            res == LOCAL_GL_CONDITION_SATISFIED);
+        }
+        return JS::NumberValue(sync.mSignaled ? LOCAL_GL_SIGNALED
+                                              : LOCAL_GL_UNSIGNALED);
+      }
+      default:
+        EnqueueError_ArgEnum("pname", pname);
+        return JS::NullValue();
+    }
+  }());
+}
+
+GLenum ClientWebGLContext::ClientWaitSync(WebGLSyncJS& sync,
+                                          const GLbitfield flags,
+                                          const GLuint64 timeout) const {
+  const FuncScope funcScope(*this, "clientWaitSync");
+  if (IsContextLost()) return LOCAL_GL_WAIT_FAILED;
+  if (!sync.ValidateUsable(*this, "sync")) return LOCAL_GL_WAIT_FAILED;
+
+  if (flags != 0 && flags != LOCAL_GL_SYNC_FLUSH_COMMANDS_BIT) {
+    EnqueueError(LOCAL_GL_INVALID_VALUE,
+                 "`flags` must be SYNC_FLUSH_COMMANDS_BIT or 0.");
+    return LOCAL_GL_WAIT_FAILED;
+  }
+
+  const auto ret = [&]() {
+    const auto& inProcess = mNotLost->inProcess;
+    if (inProcess) {
+      return inProcess->ClientWaitSync(sync.mId, flags, timeout);
+    }
+    const auto& child = mNotLost->outOfProcess;
+    child->FlushPendingCmds();
+    GLenum ret = {};
+    if (!child->SendClientWaitSync(sync.mId, flags, timeout, &ret)) {
+      ret = {};
+    }
+    return ret;
+  }();
+
+  switch (ret) {
+    case LOCAL_GL_CONDITION_SATISFIED:
+    case LOCAL_GL_ALREADY_SIGNALED:
+      sync.mSignaled = true;
+      break;
+  }
+
+  // -
+
+  const bool canBeAvailable =
+      (sync.mCanBeAvailable || StaticPrefs::webgl_allow_immediate_queries());
+  if (!canBeAvailable) {
+    constexpr uint8_t WARN_AT = 100;
+    if (sync.mNumQueriesBeforeFirstFrameBoundary <= WARN_AT) {
+      sync.mNumQueriesBeforeFirstFrameBoundary += 1;
+      if (sync.mNumQueriesBeforeFirstFrameBoundary == WARN_AT) {
+        EnqueueWarning(
+            "ClientWaitSync must return TIMEOUT_EXPIRED until control has"
+            " returned to the user agent's main loop, but was polled %hhu "
+            "times. Are you spin-locking? (only warns once)",
+            sync.mNumQueriesBeforeFirstFrameBoundary);
+      }
+    }
+    return LOCAL_GL_TIMEOUT_EXPIRED;
+  }
+
+  return ret;
+}
+
+void ClientWebGLContext::WaitSync(const WebGLSyncJS& sync,
+                                  const GLbitfield flags,
+                                  const GLint64 timeout) const {
+  const FuncScope funcScope(*this, "waitSync");
+  if (IsContextLost()) return;
+  if (!sync.ValidateUsable(*this, "sync")) return;
+
+  if (flags != 0) {
+    EnqueueError(LOCAL_GL_INVALID_VALUE, "`flags` must be 0.");
+    return;
+  }
+  if (timeout != -1) {
+    EnqueueError(LOCAL_GL_INVALID_VALUE, "`timeout` must be TIMEOUT_IGNORED.");
+    return;
+  }
+
+  JsWarning("waitSync is a no-op.");
+}
+
+// -------------------------- Transform Feedback ---------------------------
+
+void ClientWebGLContext::BindTransformFeedback(
+    const GLenum target, WebGLTransformFeedbackJS* const tf) {
+  const FuncScope funcScope(*this, "bindTransformFeedback");
+  if (IsContextLost()) return;
+  if (tf && !tf->ValidateUsable(*this, "tf")) return;
+  auto& state = State();
+
+  if (target != LOCAL_GL_TRANSFORM_FEEDBACK) {
+    EnqueueError(LOCAL_GL_INVALID_ENUM, "`target` must be TRANSFORM_FEEDBACK.");
+    return;
+  }
+  if (state.mTfActiveAndNotPaused) {
+    EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                 "Current Transform Feedback object is active and not paused.");
+    return;
+  }
+
+  if (tf) {
+    tf->mHasBeenBound = true;
+    state.mBoundTfo = tf;
+  } else {
+    state.mBoundTfo = state.mDefaultTfo;
+  }
+
+  Run<RPROC(BindTransformFeedback)>(tf ? tf->mId : 0);
+}
+
+void ClientWebGLContext::BeginTransformFeedback(const GLenum primMode) {
+  const FuncScope funcScope(*this, "beginTransformFeedback");
+  if (IsContextLost()) return;
+  auto& state = State();
+  auto& tfo = *(state.mBoundTfo);
+
+  if (tfo.mActiveOrPaused) {
+    EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                 "Transform Feedback is already active or paused.");
+    return;
+  }
+  MOZ_ASSERT(!state.mTfActiveAndNotPaused);
+
+  auto& prog = state.mCurrentProgram;
+  if (!prog) {
+    EnqueueError(LOCAL_GL_INVALID_OPERATION, "No program in use.");
+    return;
+  }
+  const auto& linkResult = GetLinkResult(*prog);
+  if (!linkResult.success) {
+    EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                 "Program is not successfully linked.");
+    return;
+  }
+
+  auto tfBufferCount = linkResult.active.activeTfVaryings.size();
+  if (tfBufferCount &&
+      linkResult.tfBufferMode == LOCAL_GL_INTERLEAVED_ATTRIBS) {
+    tfBufferCount = 1;
+  }
+  if (!tfBufferCount) {
+    EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                 "Program does not use Transform Feedback.");
+    return;
+  }
+
+  const auto& buffers = tfo.mAttribBuffers;
+  for (const auto i : IntegerRange(tfBufferCount)) {
+    if (!buffers[i]) {
+      EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                   "Transform Feedback buffer %u is null.", i);
+      return;
+    }
+  }
+
+  switch (primMode) {
+    case LOCAL_GL_POINTS:
+    case LOCAL_GL_LINES:
+    case LOCAL_GL_TRIANGLES:
+      break;
+    default:
+      EnqueueError(LOCAL_GL_INVALID_ENUM,
+                   "`primitiveMode` must be POINTS, LINES< or TRIANGLES.");
+      return;
+  }
+
+  // -
+
+  tfo.mActiveOrPaused = true;
+  tfo.mActiveProgram = prog;
+  tfo.mActiveProgramKeepAlive = prog->mKeepAliveWeak.lock();
+  prog->mActiveTfos.insert(&tfo);
+  state.mTfActiveAndNotPaused = true;
+
+  Run<RPROC(BeginTransformFeedback)>(primMode);
+}
+
+void ClientWebGLContext::EndTransformFeedback() {
+  const FuncScope funcScope(*this, "endTransformFeedback");
+  if (IsContextLost()) return;
+  auto& state = State();
+  auto& tfo = *(state.mBoundTfo);
+
+  if (!tfo.mActiveOrPaused) {
+    EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                 "Transform Feedback is not active or paused.");
+    return;
+  }
+
+  tfo.mActiveOrPaused = false;
+  tfo.mActiveProgram->mActiveTfos.erase(&tfo);
+  tfo.mActiveProgram = nullptr;
+  tfo.mActiveProgramKeepAlive = nullptr;
+  state.mTfActiveAndNotPaused = false;
+  Run<RPROC(EndTransformFeedback)>();
+}
+
+void ClientWebGLContext::PauseTransformFeedback() {
+  const FuncScope funcScope(*this, "pauseTransformFeedback");
+  if (IsContextLost()) return;
+  auto& state = State();
+  auto& tfo = *(state.mBoundTfo);
+
+  if (!tfo.mActiveOrPaused) {
+    EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                 "Transform Feedback is not active.");
+    return;
+  }
+  if (!state.mTfActiveAndNotPaused) {
+    EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                 "Transform Feedback is already paused.");
+    return;
+  }
+
+  state.mTfActiveAndNotPaused = false;
+  Run<RPROC(PauseTransformFeedback)>();
+}
+
+void ClientWebGLContext::ResumeTransformFeedback() {
+  const FuncScope funcScope(*this, "resumeTransformFeedback");
+  if (IsContextLost()) return;
+  auto& state = State();
+  auto& tfo = *(state.mBoundTfo);
+
+  if (!tfo.mActiveOrPaused) {
+    EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                 "Transform Feedback is not active and paused.");
+    return;
+  }
+  if (state.mTfActiveAndNotPaused) {
+    EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                 "Transform Feedback is not paused.");
+    return;
+  }
+  if (state.mCurrentProgram != tfo.mActiveProgram) {
+    EnqueueError(
+        LOCAL_GL_INVALID_OPERATION,
+        "Cannot Resume Transform Feedback with a program link result different"
+        " from when Begin was called.");
+    return;
+  }
+
+  state.mTfActiveAndNotPaused = true;
+  Run<RPROC(ResumeTransformFeedback)>();
+}
+
+void ClientWebGLContext::SetFramebufferIsInOpaqueRAF(WebGLFramebufferJS* fb,
+                                                     bool value) {
+  fb->mInOpaqueRAF = value;
+  Run<RPROC(SetFramebufferIsInOpaqueRAF)>(fb->mId, value);
+}
+
+// ---------------------------- Misc Extensions ----------------------------
+void ClientWebGLContext::DrawBuffers(const dom::Sequence<GLenum>& buffers) {
+  const auto range = MakeRange(buffers);
+  const auto vec = std::vector<GLenum>(range.begin().get(), range.end().get());
+  Run<RPROC(DrawBuffers)>(vec);
+}
+
+void ClientWebGLContext::EnqueueErrorImpl(const GLenum error,
+                                          const nsACString& text) const {
+  if (!mNotLost) return;  // Ignored if context is lost.
+  Run<RPROC(GenerateError)>(error, ToString(text));
+}
+
+void ClientWebGLContext::RequestExtension(const WebGLExtensionID ext) const {
+  Run<RPROC(RequestExtension)>(ext);
+}
+
+// -
+
+bool ClientWebGLContext::IsExtensionForbiddenForCaller(
+    const WebGLExtensionID ext, const dom::CallerType callerType) const {
+  if (callerType == dom::CallerType::System) {
+    return false;
+  }
+
+  if (StaticPrefs::webgl_enable_privileged_extensions()) {
+    return false;
+  }
+
+  switch (ext) {
+    case WebGLExtensionID::MOZ_debug:
+      return true;
+
+    case WebGLExtensionID::WEBGL_debug_renderer_info:
+      return ShouldResistFingerprinting(RFPTarget::WebGLRenderInfo) ||
+             !StaticPrefs::webgl_enable_debug_renderer_info();
+
+    case WebGLExtensionID::WEBGL_debug_shaders:
+      return ShouldResistFingerprinting(RFPTarget::WebGLRenderInfo);
+
+    default:
+      return false;
+  }
+}
+
+bool ClientWebGLContext::IsSupported(const WebGLExtensionID ext,
+                                     const dom::CallerType callerType) const {
+  if (IsExtensionForbiddenForCaller(ext, callerType)) {
+    return false;
+  }
+
+  const auto& limits = Limits();
+  return limits.supportedExtensions[ext];
+}
+
+void ClientWebGLContext::GetSupportedExtensions(
+    dom::Nullable<nsTArray<nsString>>& retval,
+    const dom::CallerType callerType) const {
+  retval.SetNull();
+  if (!mNotLost) return;
+
+  auto& retarr = retval.SetValue();
+  for (const auto i : MakeEnumeratedRange(WebGLExtensionID::Max)) {
+    if (!IsSupported(i, callerType)) continue;
+
+    const auto& extStr = GetExtensionName(i);
+    retarr.AppendElement(NS_ConvertUTF8toUTF16(extStr));
+  }
+}
+
+// -
+
+void ClientWebGLContext::GetSupportedProfilesASTC(
+    dom::Nullable<nsTArray<nsString>>& retval) const {
+  retval.SetNull();
+  if (!mNotLost) return;
+  const auto& limits = Limits();
+
+  auto& retarr = retval.SetValue();
+  retarr.AppendElement(u"ldr"_ns);
+  if (limits.astcHdr) {
+    retarr.AppendElement(u"hdr"_ns);
+  }
+}
+
+void ClientWebGLContext::ProvokingVertex(const GLenum rawMode) const {
+  const FuncScope funcScope(*this, "provokingVertex");
+  if (IsContextLost()) return;
+
+  const auto mode = webgl::AsEnumCase<webgl::ProvokingVertex>(rawMode);
+  if (!mode) {
+    EnqueueError_ArgEnum("mode", rawMode);
+    return;
+  }
+
+  Run<RPROC(ProvokingVertex)>(*mode);
+
+  funcScope.mKeepNotLostOrNull->state.mProvokingVertex = *mode;
+}
+
+// -
+
+uint32_t ClientWebGLContext::GetPrincipalHashValue() const {
+  if (mCanvasElement) {
+    return mCanvasElement->NodePrincipal()->GetHashValue();
+  }
+  if (mOffscreenCanvas) {
+    nsIGlobalObject* global = mOffscreenCanvas->GetOwnerGlobal();
+    if (global) {
+      nsIPrincipal* principal = global->PrincipalOrNull();
+      if (principal) {
+        return principal->GetHashValue();
+      }
+    }
+  }
+  return 0;
+}
+
+// ---------------------------
+
+void ClientWebGLContext::EnqueueError_ArgEnum(const char* const argName,
+                                              const GLenum val) const {
+  EnqueueError(LOCAL_GL_INVALID_ENUM, "Bad `%s`: 0x%04x", argName, val);
+}
+
+// -
+// WebGLProgramJS
+
+void ClientWebGLContext::AttachShader(WebGLProgramJS& prog,
+                                      WebGLShaderJS& shader) const {
+  const FuncScope funcScope(*this, "attachShader");
+  if (IsContextLost()) return;
+  if (!prog.ValidateUsable(*this, "program")) return;
+  if (!shader.ValidateUsable(*this, "shader")) return;
+
+  auto& slot = *MaybeFind(prog.mNextLink_Shaders, shader.mType);
+  if (slot.shader) {
+    if (&shader == slot.shader) {
+      EnqueueError(LOCAL_GL_INVALID_OPERATION, "`shader` is already attached.");
+    } else {
+      EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                   "Only one of each type of"
+                   " shader may be attached to a program.");
+    }
+    return;
+  }
+  slot = {&shader, shader.mKeepAliveWeak.lock()};
+
+  Run<RPROC(AttachShader)>(prog.mId, shader.mId);
+}
+
+void ClientWebGLContext::BindAttribLocation(WebGLProgramJS& prog,
+                                            const GLuint location,
+                                            const nsAString& name) const {
+  const FuncScope funcScope(*this, "detachShader");
+  if (IsContextLost()) return;
+  if (!prog.ValidateUsable(*this, "program")) return;
+
+  const auto& nameU8 = ToString(NS_ConvertUTF16toUTF8(name));
+  Run<RPROC(BindAttribLocation)>(prog.mId, location, nameU8);
+}
+
+void ClientWebGLContext::DetachShader(WebGLProgramJS& prog,
+                                      const WebGLShaderJS& shader) const {
+  const FuncScope funcScope(*this, "detachShader");
+  if (IsContextLost()) return;
+  if (!prog.ValidateUsable(*this, "program")) return;
+  if (!shader.ValidateUsable(*this, "shader")) return;
+
+  auto& slot = *MaybeFind(prog.mNextLink_Shaders, shader.mType);
+
+  if (slot.shader != &shader) {
+    EnqueueError(LOCAL_GL_INVALID_OPERATION, "`shader` is not attached.");
+    return;
+  }
+  slot = {};
+
+  Run<RPROC(DetachShader)>(prog.mId, shader.mId);
+}
+
+void ClientWebGLContext::GetAttachedShaders(
+    const WebGLProgramJS& prog,
+    dom::Nullable<nsTArray<RefPtr<WebGLShaderJS>>>& retval) const {
+  const FuncScope funcScope(*this, "getAttachedShaders");
+  if (IsContextLost()) return;
+  if (!prog.ValidateUsable(*this, "program")) return;
+
+  auto& arr = retval.SetValue();
+  for (const auto& pair : prog.mNextLink_Shaders) {
+    const auto& attachment = pair.second;
+    if (!attachment.shader) continue;
+    arr.AppendElement(attachment.shader);
+  }
+}
+
+void ClientWebGLContext::LinkProgram(WebGLProgramJS& prog) const {
+  const FuncScope funcScope(*this, "linkProgram");
+  if (IsContextLost()) return;
+  if (!prog.ValidateUsable(*this, "program")) return;
+
+  if (!prog.mActiveTfos.empty()) {
+    EnqueueError(LOCAL_GL_INVALID_OPERATION,
+                 "Program still in use by active or paused"
+                 " Transform Feedback objects.");
+    return;
+  }
+
+  prog.mResult = std::make_shared<webgl::LinkResult>();
+  prog.mUniformLocByName = Nothing();
+  prog.mUniformBlockBindings = {};
+  Run<RPROC(LinkProgram)>(prog.mId);
+}
+
+void ClientWebGLContext::TransformFeedbackVaryings(
+    WebGLProgramJS& prog, const dom::Sequence<nsString>& varyings,
+    const GLenum bufferMode) const {
+  const FuncScope funcScope(*this, "transformFeedbackVaryings");
+  if (IsContextLost()) return;
+  if (!prog.ValidateUsable(*this, "program")) return;
+
+  std::vector<std::string> varyingsU8;
+  varyingsU8.reserve(varyings.Length());
+  for (const auto& cur : varyings) {
+    const auto curU8 = ToString(NS_ConvertUTF16toUTF8(cur));
+    varyingsU8.push_back(curU8);
+  }
+
+  Run<RPROC(TransformFeedbackVaryings)>(prog.mId, varyingsU8, bufferMode);
+}
+
+void ClientWebGLContext::UniformBlockBinding(WebGLProgramJS& prog,
+                                             const GLuint blockIndex,
+                                             const GLuint blockBinding) const {
+  const FuncScope funcScope(*this, "uniformBlockBinding");
+  if (IsContextLost()) return;
+  if (!prog.ValidateUsable(*this, "program")) return;
+  const auto& state = State();
+
+  (void)GetLinkResult(prog);
+  auto& list = prog.mUniformBlockBindings;
+  if (blockIndex >= list.size()) {
+    EnqueueError(
+        LOCAL_GL_INVALID_VALUE,
+        "`blockIndex` (%u) must be less than ACTIVE_UNIFORM_BLOCKS (%zu).",
+        blockIndex, list.size());
+    return;
+  }
+  if (blockBinding >= state.mBoundUbos.size()) {
+    EnqueueError(LOCAL_GL_INVALID_VALUE,
+                 "`blockBinding` (%u) must be less than "
+                 "MAX_UNIFORM_BUFFER_BINDINGS (%zu).",
+                 blockBinding, state.mBoundUbos.size());
+    return;
+  }
+
+  list[blockIndex] = blockBinding;
+  Run<RPROC(UniformBlockBinding)>(prog.mId, blockIndex, blockBinding);
+}
+
+// WebGLProgramJS link result reflection
+
+already_AddRefed<WebGLActiveInfoJS> ClientWebGLContext::GetActiveAttrib(
+    const WebGLProgramJS& prog, const GLuint index) {
+  const FuncScope funcScope(*this, "getActiveAttrib");
+  if (IsContextLost()) return nullptr;
+  if (!prog.ValidateUsable(*this, "program")) return nullptr;
+
+  const auto& res = GetLinkResult(prog);
+  const auto& list = res.active.activeAttribs;
+  if (index >= list.size()) {
+    EnqueueError(LOCAL_GL_INVALID_VALUE, "`index` too large.");
+    return nullptr;
+  }
+
+  const auto& info = list[index];
+  return AsAddRefed(new WebGLActiveInfoJS(info));
+}
+
+already_AddRefed<WebGLActiveInfoJS> ClientWebGLContext::GetActiveUniform(
+    const WebGLProgramJS& prog, const GLuint index) {
+  const FuncScope funcScope(*this, "getActiveUniform");
+  if (IsContextLost()) return nullptr;
+  if (!prog.ValidateUsable(*this, "program")) return nullptr;
+
+  const auto& res = GetLinkResult(prog);
+  const auto& list = res.active.activeUniforms;
+  if (index >= list.size()) {
+    EnqueueError(LOCAL_GL_INVALID_VALUE, "`index` too large.");
+    return nullptr;
+  }
+
+  const auto& info = list[index];
+  return AsAddRefed(new WebGLActiveInfoJS(info));
+}
+
+void ClientWebGLContext::GetActiveUniformBlockName(const WebGLProgramJS& prog,
+                                                   const GLuint index,
+                                                   nsAString& retval) const {
+  retval.SetIsVoid(true);
+  const FuncScope funcScope(*this, "getActiveUniformBlockName");
+  if (IsContextLost()) return;
+  if (!prog.ValidateUsable(*this, "program")) return;
+
+  const auto& res = GetLinkResult(prog);
+  if (!res.success) {
+    EnqueueError(LOCAL_GL_INVALID_OPERATION, "Program has not been linked.");
+    return;
+  }
+
+  const auto& list = res.active.activeUniformBlocks;
+  if (index >= list.size()) {
+    EnqueueError(LOCAL_GL_INVALID_VALUE, "`index` too large.");
+    return;
+  }
+
+  const auto& block = list[index];
+  CopyUTF8toUTF16(block.name, retval);
+}
+
+void ClientWebGLContext::GetActiveUniformBlockParameter(
+    JSContext* const cx, const WebGLProgramJS& prog, const GLuint index,
+    const GLenum pname, JS::MutableHandle<JS::Value> retval, ErrorResult& rv) {
+  retval.set(JS::NullValue());
+  const FuncScope funcScope(*this, "getActiveUniformBlockParameter");
+  if (IsContextLost()) return;
+  if (!prog.ValidateUsable(*this, "program")) return;
+
+  const auto& res = GetLinkResult(prog);
+  const auto& list = res.active.activeUniformBlocks;
+  if (index >= list.size()) {
+    EnqueueError(LOCAL_GL_INVALID_VALUE, "`index` too large.");
+    return;
+  }
+  const auto& block = list[index];
+
+  retval.set([&]() -> JS::Value {
+    switch (pname) {
+      case LOCAL_GL_UNIFORM_BLOCK_BINDING:
+        return JS::NumberValue(prog.mUniformBlockBindings[index]);
+
+      case LOCAL_GL_UNIFORM_BLOCK_DATA_SIZE:
+        return JS::NumberValue(block.dataSize);
+
+      case LOCAL_GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:
+        return JS::NumberValue(block.activeUniformIndices.size());
+
+      case LOCAL_GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES: {
+        const auto& indices = block.activeUniformIndices;
+        return Create<dom::Uint32Array>(cx, this, indices, rv);
+      }
+
+      case LOCAL_GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
+        return JS::BooleanValue(block.referencedByVertexShader);
+
+      case LOCAL_GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
+        return JS::BooleanValue(block.referencedByFragmentShader);
+
+      default:
+        EnqueueError_ArgEnum("pname", pname);
+        return JS::NullValue();
+    }
+  }());
+}
+
+void ClientWebGLContext::GetActiveUniforms(
+    JSContext* const cx, const WebGLProgramJS& prog,
+    const dom::Sequence<GLuint>& uniformIndices, const GLenum pname,
+    JS::MutableHandle<JS::Value> retval) const {
+  retval.set(JS::NullValue());
+  const FuncScope funcScope(*this, "getActiveUniforms");
+  if (IsContextLost()) return;
+  if (!prog.ValidateUsable(*this, "program")) return;
+
+  const auto& res = GetLinkResult(prog);
+  const auto& list = res.active.activeUniforms;
+
+  const auto count = uniformIndices.Length();
+  JS::Rooted<JSObject*> array(cx, JS::NewArrayObject(cx, count));
+  if (!array) return;  // Just bail.
+
+  for (const auto i : IntegerRange(count)) {
+    const auto index = uniformIndices[i];
+    if (index >= list.size()) {
+      EnqueueError(LOCAL_GL_INVALID_VALUE,
+                   "`uniformIndices[%u]`: `%u` too large.", i, index);
+      return;
+    }
+    const auto& uniform = list[index];
+
+    JS::Rooted<JS::Value> value(cx);
+    switch (pname) {
+      case LOCAL_GL_UNIFORM_TYPE:
+        value = JS::NumberValue(uniform.elemType);
+        break;
+
+      case LOCAL_GL_UNIFORM_SIZE:
+        value = JS::NumberValue(uniform.elemCount);
+        break;
+
+      case LOCAL_GL_UNIFORM_BLOCK_INDEX:
+        value = JS::NumberValue(uniform.block_index);
+        break;
+
+      case LOCAL_GL_UNIFORM_OFFSET:
+        value = JS::NumberValue(uniform.block_offset);
+        break;
+
+      case LOCAL_GL_UNIFORM_ARRAY_STRIDE:
+        value = JS::NumberValue(uniform.block_arrayStride);
+        break;
+
+      case LOCAL_GL_UNIFORM_MATRIX_STRIDE:
+        value = JS::NumberValue(uniform.block_matrixStride);
+        break;
+
+      case LOCAL_GL_UNIFORM_IS_ROW_MAJOR:
+        value = JS::BooleanValue(uniform.block_isRowMajor);
+        break;
+
+      default:
+        EnqueueError_ArgEnum("pname", pname);
+        return;
+    }
+    if (!JS_DefineElement(cx, array, i, value, JSPROP_ENUMERATE)) return;
+  }
+
+  retval.setObject(*array);
+}
+
+already_AddRefed<WebGLActiveInfoJS>
+ClientWebGLContext::GetTransformFeedbackVarying(const WebGLProgramJS& prog,
+                                                const GLuint index) {
+  const FuncScope funcScope(*this, "getTransformFeedbackVarying");
+  if (IsContextLost()) return nullptr;
+  if (!prog.ValidateUsable(*this, "program")) return nullptr;
+
+  const auto& res = GetLinkResult(prog);
+  const auto& list = res.active.activeTfVaryings;
+  if (index >= list.size()) {
+    EnqueueError(LOCAL_GL_INVALID_VALUE, "`index` too large.");
+    return nullptr;
+  }
+
+  const auto& info = list[index];
+  return AsAddRefed(new WebGLActiveInfoJS(info));
+}
+
+GLint ClientWebGLContext::GetAttribLocation(const WebGLProgramJS& prog,
+                                            const nsAString& name) const {
+  const FuncScope funcScope(*this, "getAttribLocation");
+  if (IsContextLost()) return -1;
+  if (!prog.ValidateUsable(*this, "program")) return -1;
+
+  const auto nameU8 = ToString(NS_ConvertUTF16toUTF8(name));
+  const auto& res = GetLinkResult(prog);
+  for (const auto& cur : res.active.activeAttribs) {
+    if (cur.name == nameU8) return cur.location;
+  }
+
+  const auto err = CheckGLSLVariableName(mIsWebGL2, nameU8);
+  if (err) {
+    EnqueueError(err->type, "%s", err->info.c_str());
+  }
+  return -1;
+}
+
+GLint ClientWebGLContext::GetFragDataLocation(const WebGLProgramJS& prog,
+                                              const nsAString& name) const {
+  const FuncScope funcScope(*this, "getFragDataLocation");
+  if (IsContextLost()) return -1;
+  if (!prog.ValidateUsable(*this, "program")) return -1;
+
+  const auto nameU8 = ToString(NS_ConvertUTF16toUTF8(name));
+
+  const auto err = CheckGLSLVariableName(mIsWebGL2, nameU8);
+  if (err) {
+    EnqueueError(*err);
+    return -1;
+  }
+
+  return [&]() {
+    const auto& inProcess = mNotLost->inProcess;
+    if (inProcess) {
+      return inProcess->GetFragDataLocation(prog.mId, nameU8);
+    }
+    const auto& child = mNotLost->outOfProcess;
+    child->FlushPendingCmds();
+    GLint ret = {};
+    if (!child->SendGetFragDataLocation(prog.mId, nameU8, &ret)) {
+      ret = {};
+    }
+    return ret;
+  }();
+}
+
+GLuint ClientWebGLContext::GetUniformBlockIndex(
+    const WebGLProgramJS& prog, const nsAString& blockName) const {
+  const FuncScope funcScope(*this, "getUniformBlockIndex");
+  if (IsContextLost()) return LOCAL_GL_INVALID_INDEX;
+  if (!prog.ValidateUsable(*this, "program")) return LOCAL_GL_INVALID_INDEX;
+
+  const auto nameU8 = ToString(NS_ConvertUTF16toUTF8(blockName));
+
+  const auto& res = GetLinkResult(prog);
+  const auto& list = res.active.activeUniformBlocks;
+  for (const auto i : IntegerRange(list.size())) {
+    const auto& cur = list[i];
+    if (cur.name == nameU8) {
+      return i;
+    }
+  }
+  return LOCAL_GL_INVALID_INDEX;
+}
+
+void ClientWebGLContext::GetUniformIndices(
+    const WebGLProgramJS& prog, const dom::Sequence<nsString>& uniformNames,
+    dom::Nullable<nsTArray<GLuint>>& retval) const {
+  const FuncScope funcScope(*this, "getUniformIndices");
+  if (IsContextLost()) return;
+  if (!prog.ValidateUsable(*this, "program")) return;
+
+  const auto& res = GetLinkResult(prog);
+  auto ret = nsTArray<GLuint>(uniformNames.Length());
+
+  for (const auto& queriedNameU16 : uniformNames) {
+    const auto queriedName = ToString(NS_ConvertUTF16toUTF8(queriedNameU16));
+    const auto impliedProperArrayQueriedName = queriedName + "[0]";
+
+    GLuint activeId = LOCAL_GL_INVALID_INDEX;
+    for (const auto i : IntegerRange(res.active.activeUniforms.size())) {
+      // O(N^2) ok for small N.
+      const auto& activeInfoForI = res.active.activeUniforms[i];
+      if (queriedName == activeInfoForI.name ||
+          impliedProperArrayQueriedName == activeInfoForI.name) {
+        activeId = i;
+        break;
+      }
+    }
+    ret.AppendElement(activeId);
+  }
+
+  retval.SetValue(std::move(ret));
+}
+
+already_AddRefed<WebGLUniformLocationJS> ClientWebGLContext::GetUniformLocation(
+    const WebGLProgramJS& prog, const nsAString& name) const {
+  const FuncScope funcScope(*this, "getUniformLocation");
+  if (IsContextLost()) return nullptr;
+  if (!prog.ValidateUsable(*this, "program")) return nullptr;
+
+  const auto& res = GetLinkResult(prog);
+
+  if (!prog.mUniformLocByName) {
+    // Cache a map from name->location.
+    // Since the only way to set uniforms requires calling GetUniformLocation,
+    // we expect apps to query most active uniforms once for each scalar or
+    // array. NB: Uniform array setters do have overflow semantics, even though
+    // uniform locations aren't guaranteed contiguous, but GetUniformLocation
+    // must still be called once per array.
+    prog.mUniformLocByName.emplace();
+
+    for (const auto& activeUniform : res.active.activeUniforms) {
+      if (activeUniform.block_index != -1) continue;
+
+      auto locName = activeUniform.name;
+      const auto indexed = webgl::ParseIndexed(locName);
+      if (indexed) {
+        locName = indexed->name;
+      }
+
+      const auto err = CheckGLSLVariableName(mIsWebGL2, locName);
+      if (err) continue;
+
+      const auto baseLength = locName.size();
+      for (const auto& pair : activeUniform.locByIndex) {
+        if (indexed) {
+          locName.erase(baseLength);  // Erase previous "[N]".
+          locName += '[';
+          locName += std::to_string(pair.first);
+          locName += ']';
+        }
+        const auto locInfo =
+            WebGLProgramJS::UniformLocInfo{pair.second, activeUniform.elemType};
+        prog.mUniformLocByName->insert({locName, locInfo});
+      }
+    }
+  }
+  const auto& locByName = *(prog.mUniformLocByName);
+
+  const auto nameU8 = ToString(NS_ConvertUTF16toUTF8(name));
+  auto loc = MaybeFind(locByName, nameU8);
+  if (!loc) {
+    loc = MaybeFind(locByName, nameU8 + "[0]");
+  }
+  if (!loc) {
+    const auto err = CheckGLSLVariableName(mIsWebGL2, nameU8);
+    if (err) {
+      EnqueueError(err->type, "%s", err->info.c_str());
+    }
+    return nullptr;
+  }
+
+  return AsAddRefed(new WebGLUniformLocationJS(*this, prog.mResult,
+                                               loc->location, loc->elemType));
+}
+
+std::array<uint16_t, 3> ValidUploadElemTypes(const GLenum elemType) {
+  std::vector<GLenum> ret;
+  switch (elemType) {
+    case LOCAL_GL_BOOL:
+      ret = {LOCAL_GL_FLOAT, LOCAL_GL_INT, LOCAL_GL_UNSIGNED_INT};
+      break;
+    case LOCAL_GL_BOOL_VEC2:
+      ret = {LOCAL_GL_FLOAT_VEC2, LOCAL_GL_INT_VEC2,
+             LOCAL_GL_UNSIGNED_INT_VEC2};
+      break;
+    case LOCAL_GL_BOOL_VEC3:
+      ret = {LOCAL_GL_FLOAT_VEC3, LOCAL_GL_INT_VEC3,
+             LOCAL_GL_UNSIGNED_INT_VEC3};
+      break;
+    case LOCAL_GL_BOOL_VEC4:
+      ret = {LOCAL_GL_FLOAT_VEC4, LOCAL_GL_INT_VEC4,
+             LOCAL_GL_UNSIGNED_INT_VEC4};
+      break;
+
+    case LOCAL_GL_SAMPLER_2D:
+    case LOCAL_GL_SAMPLER_3D:
+    case LOCAL_GL_SAMPLER_CUBE:
+    case LOCAL_GL_SAMPLER_2D_SHADOW:
+    case LOCAL_GL_SAMPLER_2D_ARRAY:
+    case LOCAL_GL_SAMPLER_2D_ARRAY_SHADOW:
+    case LOCAL_GL_SAMPLER_CUBE_SHADOW:
+    case LOCAL_GL_INT_SAMPLER_2D:
+    case LOCAL_GL_INT_SAMPLER_3D:
+    case LOCAL_GL_INT_SAMPLER_CUBE:
+    case LOCAL_GL_INT_SAMPLER_2D_ARRAY:
+    case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D:
+    case LOCAL_GL_UNSIGNED_INT_SAMPLER_3D:
+    case LOCAL_GL_UNSIGNED_INT_SAMPLER_CUBE:
+    case LOCAL_GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
+      ret = {LOCAL_GL_INT};
+      break;
+
+    default:
+      ret = {elemType};
+      break;
+  }
+
+  std::array<uint16_t, 3> arr = {};
+  MOZ_ASSERT(arr[2] == 0);
+  for (const auto i : IntegerRange(ret.size())) {
+    arr[i] = AssertedCast<uint16_t>(ret[i]);
+  }
+  return arr;
+}
+
+void ClientWebGLContext::GetProgramInfoLog(const WebGLProgramJS& prog,
+                                           nsAString& retval) const {
+  retval.SetIsVoid(true);
+  const FuncScope funcScope(*this, "getProgramInfoLog");
+  if (IsContextLost()) return;
+  if (!prog.ValidateUsable(*this, "program")) return;
+
+  const auto& res = GetLinkResult(prog);
+  CopyUTF8toUTF16(res.log, retval);
+}
+
+void ClientWebGLContext::GetProgramParameter(
+    JSContext* const js, const WebGLProgramJS& prog, const GLenum pname,
+    JS::MutableHandle<JS::Value> retval) const {
+  retval.set(JS::NullValue());
+  const FuncScope funcScope(*this, "getProgramParameter");
+  if (IsContextLost()) return;
+  if (!prog.ValidateUsable(*this, "program")) return;
+
+  retval.set([&]() -> JS::Value {
+    switch (pname) {
+      case LOCAL_GL_DELETE_STATUS:
+        // "Is flagged for deletion?"
+        return JS::BooleanValue(!prog.mKeepAlive);
+      case LOCAL_GL_VALIDATE_STATUS:
+        return JS::BooleanValue(prog.mLastValidate);
+      case LOCAL_GL_ATTACHED_SHADERS: {
+        size_t shaders = 0;
+        for (const auto& pair : prog.mNextLink_Shaders) {
+          const auto& slot = pair.second;
+          if (slot.shader) {
+            shaders += 1;
+          }
+        }
+        return JS::NumberValue(shaders);
+      }
+      default:
+        break;
+    }
+
+    const auto& res = GetLinkResult(prog);
+
+    switch (pname) {
+      case LOCAL_GL_LINK_STATUS:
+        return JS::BooleanValue(res.success);
+
+      case LOCAL_GL_ACTIVE_ATTRIBUTES:
+        return JS::NumberValue(res.active.activeAttribs.size());
+
+      case LOCAL_GL_ACTIVE_UNIFORMS:
+        return JS::NumberValue(res.active.activeUniforms.size());
+
+      case LOCAL_GL_TRANSFORM_FEEDBACK_BUFFER_MODE:
+        if (!mIsWebGL2) break;
+        return JS::NumberValue(res.tfBufferMode);
+
+      case LOCAL_GL_TRANSFORM_FEEDBACK_VARYINGS:
+        if (!mIsWebGL2) break;
+        return JS::NumberValue(res.active.activeTfVaryings.size());
+
+      case LOCAL_GL_ACTIVE_UNIFORM_BLOCKS:
+        if (!mIsWebGL2) break;
+        return JS::NumberValue(res.active.activeUniformBlocks.size());
+
+      default:
+        break;
+    }
+    EnqueueError_ArgEnum("pname", pname);
+    return JS::NullValue();
+  }());
+}
+
+// -
+// WebGLShaderJS
+
+void ClientWebGLContext::CompileShader(WebGLShaderJS& shader) const {
+  const FuncScope funcScope(*this, "compileShader");
+  if (IsContextLost()) return;
+  if (!shader.ValidateUsable(*this, "shader")) return;
+
+  shader.mResult = {};
+  Run<RPROC(CompileShader)>(shader.mId);
+}
+
+void ClientWebGLContext::GetShaderInfoLog(const WebGLShaderJS& shader,
+                                          nsAString& retval) const {
+  retval.SetIsVoid(true);
+  const FuncScope funcScope(*this, "getShaderInfoLog");
+  if (IsContextLost()) return;
+  if (!shader.ValidateUsable(*this, "shader")) return;
+
+  const auto& result = GetCompileResult(shader);
+  CopyUTF8toUTF16(result.log, retval);
+}
+
+void ClientWebGLContext::GetShaderParameter(
+    JSContext* const cx, const WebGLShaderJS& shader, const GLenum pname,
+    JS::MutableHandle<JS::Value> retval) const {
+  retval.set(JS::NullValue());
+  const FuncScope funcScope(*this, "getShaderParameter");
+  if (IsContextLost()) return;
+  if (!shader.ValidateUsable(*this, "shader")) return;
+
+  retval.set([&]() -> JS::Value {
+    switch (pname) {
+      case LOCAL_GL_SHADER_TYPE:
+        return JS::NumberValue(shader.mType);
+
+      case LOCAL_GL_DELETE_STATUS:  // "Is flagged for deletion?"
+        return JS::BooleanValue(!shader.mKeepAlive);
+
+      case LOCAL_GL_COMPILE_STATUS: {
+        const auto& result = GetCompileResult(shader);
+        return JS::BooleanValue(result.success);
+      }
+
+      default:
+        EnqueueError_ArgEnum("pname", pname);
+        return JS::NullValue();
+    }
+  }());
+}
+
+void ClientWebGLContext::GetShaderSource(const WebGLShaderJS& shader,
+                                         nsAString& retval) const {
+  retval.SetIsVoid(true);
+  const FuncScope funcScope(*this, "getShaderSource");
+  if (IsContextLost()) return;
+  if (!shader.ValidateUsable(*this, "shader")) return;
+
+  CopyUTF8toUTF16(shader.mSource, retval);
+}
+
+void ClientWebGLContext::GetTranslatedShaderSource(const WebGLShaderJS& shader,
+                                                   nsAString& retval) const {
+  retval.SetIsVoid(true);
+  const FuncScope funcScope(*this, "getTranslatedShaderSource");
+  if (IsContextLost()) return;
+  if (!shader.ValidateUsable(*this, "shader")) return;
+
+  const auto& result = GetCompileResult(shader);
+  CopyUTF8toUTF16(result.translatedSource, retval);
+}
+
+void ClientWebGLContext::ShaderSource(WebGLShaderJS& shader,
+                                      const nsAString& sourceU16) const {
+  const FuncScope funcScope(*this, "shaderSource");
+  if (IsContextLost()) return;
+  if (!shader.ValidateUsable(*this, "shader")) return;
+
+  shader.mSource = ToString(NS_ConvertUTF16toUTF8(sourceU16));
+  Run<RPROC(ShaderSource)>(shader.mId, shader.mSource);
+}
+
+// -
+
+const webgl::CompileResult& ClientWebGLContext::GetCompileResult(
+    const WebGLShaderJS& shader) const {
+  if (shader.mResult.pending) {
+    shader.mResult = [&]() {
+      const auto& inProcess = mNotLost->inProcess;
+      if (inProcess) {
+        return inProcess->GetCompileResult(shader.mId);
+      }
+      const auto& child = mNotLost->outOfProcess;
+      child->FlushPendingCmds();
+      webgl::CompileResult ret = {};
+      if (!child->SendGetCompileResult(shader.mId, &ret)) {
+        ret = {};
+      }
+      return ret;
+    }();
+  }
+  return shader.mResult;
+}
+
+const webgl::LinkResult& ClientWebGLContext::GetLinkResult(
+    const WebGLProgramJS& prog) const {
+  if (prog.mResult->pending) {
+    const auto notLost =
+        mNotLost;  // Hold a strong-ref to prevent LoseContext=>UAF.
+    if (!notLost) return *(prog.mResult);
+
+    *(prog.mResult) = [&]() {
+      const auto& inProcess = mNotLost->inProcess;
+      if (inProcess) {
+        return inProcess->GetLinkResult(prog.mId);
+      }
+      const auto& child = mNotLost->outOfProcess;
+      child->FlushPendingCmds();
+      webgl::LinkResult ret;
+      if (!child->SendGetLinkResult(prog.mId, &ret)) {
+        ret = {};
+      }
+      return ret;
+    }();
+
+    prog.mUniformBlockBindings.resize(
+        prog.mResult->active.activeUniformBlocks.size());
+
+    auto& state = State();
+    if (state.mCurrentProgram == &prog && prog.mResult->success) {
+      state.mActiveLinkResult = prog.mResult;
+    }
+  }
+  return *(prog.mResult);
+}
+
+#undef RPROC
+
+// ---------------------------
+
+Maybe<Range<uint8_t>> ClientWebGLContext::ValidateArrayBufferView(
+    const Span<uint8_t>& bytes, size_t elemSize, GLuint elemOffset,
+    GLuint elemCountOverride, const GLenum errorEnum) const {
+  size_t elemCount = bytes.Length() / elemSize;
+  if (elemOffset > elemCount) {
+    EnqueueError(errorEnum, "Invalid offset into ArrayBufferView.");
+    return Nothing();
+  }
+  elemCount -= elemOffset;
+
+  if (elemCountOverride) {
+    if (elemCountOverride > elemCount) {
+      EnqueueError(errorEnum, "Invalid sub-length for ArrayBufferView.");
+      return Nothing();
+    }
+    elemCount = elemCountOverride;
+  }
+
+  return Some(Range<uint8_t>(
+      bytes.Subspan(elemOffset * elemSize, elemCount * elemSize)));
+}
+
+// ---------------------------
+
+webgl::ObjectJS::ObjectJS(const ClientWebGLContext& webgl)
+    : mGeneration(webgl.mNotLost), mId(webgl.mNotLost->state.NextId()) {}
+
+// -
+
+WebGLFramebufferJS::WebGLFramebufferJS(const ClientWebGLContext& webgl,
+                                       bool opaque)
+    : webgl::ObjectJS(webgl), mOpaque(opaque) {
+  (void)mAttachments[LOCAL_GL_DEPTH_ATTACHMENT];
+  (void)mAttachments[LOCAL_GL_STENCIL_ATTACHMENT];
+  if (!webgl.mIsWebGL2) {
+    (void)mAttachments[LOCAL_GL_DEPTH_STENCIL_ATTACHMENT];
+  }
+
+  EnsureColorAttachments();
+}
+
+void WebGLFramebufferJS::EnsureColorAttachments() {
+  const auto& webgl = Context();
+  const auto& limits = webgl->Limits();
+  auto maxColorDrawBuffers = limits.maxColorDrawBuffers;
+  if (!webgl->mIsWebGL2 &&
+      !webgl->IsExtensionEnabled(WebGLExtensionID::WEBGL_draw_buffers)) {
+    maxColorDrawBuffers = 1;
+  }
+  for (const auto i : IntegerRange(maxColorDrawBuffers)) {
+    (void)mAttachments[LOCAL_GL_COLOR_ATTACHMENT0 + i];
+  }
+}
+
+WebGLProgramJS::WebGLProgramJS(const ClientWebGLContext& webgl)
+    : webgl::ObjectJS(webgl),
+      mKeepAlive(std::make_shared<webgl::ProgramKeepAlive>(*this)),
+      mKeepAliveWeak(mKeepAlive) {
+  (void)mNextLink_Shaders[LOCAL_GL_VERTEX_SHADER];
+  (void)mNextLink_Shaders[LOCAL_GL_FRAGMENT_SHADER];
+
+  mResult = std::make_shared<webgl::LinkResult>();
+}
+
+WebGLShaderJS::WebGLShaderJS(const ClientWebGLContext& webgl, const GLenum type)
+    : webgl::ObjectJS(webgl),
+      mType(type),
+      mKeepAlive(std::make_shared<webgl::ShaderKeepAlive>(*this)),
+      mKeepAliveWeak(mKeepAlive) {}
+
+WebGLTransformFeedbackJS::WebGLTransformFeedbackJS(
+    const ClientWebGLContext& webgl)
+    : webgl::ObjectJS(webgl),
+      mAttribBuffers(webgl::kMaxTransformFeedbackSeparateAttribs) {}
+
+WebGLVertexArrayJS::WebGLVertexArrayJS(const ClientWebGLContext& webgl)
+    : webgl::ObjectJS(webgl), mAttribBuffers(webgl.Limits().maxVertexAttribs) {}
+
+// -
+
+#define _(WebGLType)                                                      \
+  JSObject* WebGLType##JS::WrapObject(JSContext* const cx,                \
+                                      JS::Handle<JSObject*> givenProto) { \
+    return dom::WebGLType##_Binding::Wrap(cx, this, givenProto);          \
+  }
+
+_(WebGLBuffer)
+_(WebGLFramebuffer)
+_(WebGLProgram)
+_(WebGLQuery)
+_(WebGLRenderbuffer)
+_(WebGLSampler)
+_(WebGLShader)
+_(WebGLSync)
+_(WebGLTexture)
+_(WebGLTransformFeedback)
+_(WebGLUniformLocation)
+//_(WebGLVertexArray) // The webidl is `WebGLVertexArrayObject` :(
+
+#undef _
+
+JSObject* WebGLVertexArrayJS::WrapObject(JSContext* const cx,
+                                         JS::Handle<JSObject*> givenProto) {
+  return dom::WebGLVertexArrayObject_Binding::Wrap(cx, this, givenProto);
+}
+
+bool WebGLActiveInfoJS::WrapObject(JSContext* const cx,
+                                   JS::Handle<JSObject*> givenProto,
+                                   JS::MutableHandle<JSObject*> reflector) {
+  return dom::WebGLActiveInfo_Binding::Wrap(cx, this, givenProto, reflector);
+}
+
+bool WebGLShaderPrecisionFormatJS::WrapObject(
+    JSContext* const cx, JS::Handle<JSObject*> givenProto,
+    JS::MutableHandle<JSObject*> reflector) {
+  return dom::WebGLShaderPrecisionFormat_Binding::Wrap(cx, this, givenProto,
+                                                       reflector);
+}
+
+// ---------------------
+
+// Todo: Move this to RefPtr.h.
+template <typename T>
+void ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& callback,
+                                 const RefPtr<T>& field, const char* name,
+                                 uint32_t flags) {
+  ImplCycleCollectionTraverse(callback, const_cast<RefPtr<T>&>(field), name,
+                              flags);
+}
+
+// -
+
+template <typename T>
+void ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& callback,
+                                 const std::vector<RefPtr<T>>& field,
+                                 const char* name, uint32_t flags) {
+  for (const auto& cur : field) {
+    ImplCycleCollectionTraverse(callback, cur, name, flags);
+  }
+}
+
+template <typename T>
+void ImplCycleCollectionUnlink(std::vector<RefPtr<T>>& field) {
+  field = {};
+}
+
+// -
+
+template <typename T, size_t N>
+void ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& callback,
+                                 const std::array<RefPtr<T>, N>& field,
+                                 const char* name, uint32_t flags) {
+  for (const auto& cur : field) {
+    ImplCycleCollectionTraverse(callback, cur, name, flags);
+  }
+}
+
+template <typename T, size_t N>
+void ImplCycleCollectionUnlink(std::array<RefPtr<T>, N>& field) {
+  field = {};
+}
+
+// -
+
+template <typename T>
+void ImplCycleCollectionTraverse(
+    nsCycleCollectionTraversalCallback& callback,
+    const std::unordered_map<GLenum, RefPtr<T>>& field, const char* name,
+    uint32_t flags) {
+  for (const auto& pair : field) {
+    ImplCycleCollectionTraverse(callback, pair.second, name, flags);
+  }
+}
+
+template <typename T>
+void ImplCycleCollectionUnlink(std::unordered_map<GLenum, RefPtr<T>>& field) {
+  field = {};
+}
+
+// -
+
+void ImplCycleCollectionTraverse(
+    nsCycleCollectionTraversalCallback& callback,
+    const std::unordered_map<GLenum, WebGLFramebufferJS::Attachment>& field,
+    const char* name, uint32_t flags) {
+  for (const auto& pair : field) {
+    const auto& attach = pair.second;
+    ImplCycleCollectionTraverse(callback, attach.rb, name, flags);
+    ImplCycleCollectionTraverse(callback, attach.tex, name, flags);
+  }
+}
+
+void ImplCycleCollectionUnlink(
+    std::unordered_map<GLenum, WebGLFramebufferJS::Attachment>& field) {
+  field = {};
+}
+
+// -
+
+void ImplCycleCollectionTraverse(
+    nsCycleCollectionTraversalCallback& callback,
+    const std::unordered_map<GLenum, WebGLProgramJS::Attachment>& field,
+    const char* name, uint32_t flags) {
+  for (const auto& pair : field) {
+    const auto& attach = pair.second;
+    ImplCycleCollectionTraverse(callback, attach.shader, name, flags);
+  }
+}
+
+void ImplCycleCollectionUnlink(
+    std::unordered_map<GLenum, WebGLProgramJS::Attachment>& field) {
+  field = {};
+}
+
+// -
+
+void ImplCycleCollectionUnlink(
+    const RefPtr<ClientWebGLExtensionLoseContext>& field) {
+  const_cast<RefPtr<ClientWebGLExtensionLoseContext>&>(field) = nullptr;
+}
+void ImplCycleCollectionUnlink(const RefPtr<WebGLProgramJS>& field) {
+  const_cast<RefPtr<WebGLProgramJS>&>(field) = nullptr;
+}
+void ImplCycleCollectionUnlink(const RefPtr<WebGLShaderJS>& field) {
+  const_cast<RefPtr<WebGLShaderJS>&>(field) = nullptr;
+}
+
+// ----------------------
+
+void ImplCycleCollectionTraverse(
+    nsCycleCollectionTraversalCallback& callback,
+    const std::shared_ptr<webgl::NotLostData>& field, const char* name,
+    uint32_t flags) {
+  if (!field) return;
+
+  ImplCycleCollectionTraverse(callback, field->extensions,
+                              "NotLostData.extensions", flags);
+
+  const auto& state = field->state;
+
+  ImplCycleCollectionTraverse(callback, state.mDefaultTfo, "state.mDefaultTfo",
+                              flags);
+  ImplCycleCollectionTraverse(callback, state.mDefaultVao, "state.mDefaultVao",
+                              flags);
+
+  ImplCycleCollectionTraverse(callback, state.mCurrentProgram,
+                              "state.mCurrentProgram", flags);
+
+  ImplCycleCollectionTraverse(callback, state.mBoundBufferByTarget,
+                              "state.mBoundBufferByTarget", flags);
+  ImplCycleCollectionTraverse(callback, state.mBoundUbos, "state.mBoundUbos",
+                              flags);
+  ImplCycleCollectionTraverse(callback, state.mBoundDrawFb,
+                              "state.mBoundDrawFb", flags);
+  ImplCycleCollectionTraverse(callback, state.mBoundReadFb,
+                              "state.mBoundReadFb", flags);
+  ImplCycleCollectionTraverse(callback, state.mBoundRb, "state.mBoundRb",
+                              flags);
+  ImplCycleCollectionTraverse(callback, state.mBoundTfo, "state.mBoundTfo",
+                              flags);
+  ImplCycleCollectionTraverse(callback, state.mBoundVao, "state.mBoundVao",
+                              flags);
+  ImplCycleCollectionTraverse(callback, state.mCurrentQueryByTarget,
+                              "state.state.mCurrentQueryByTarget", flags);
+
+  for (const auto& texUnit : state.mTexUnits) {
+    ImplCycleCollectionTraverse(callback, texUnit.sampler,
+                                "state.mTexUnits[].sampler", flags);
+    ImplCycleCollectionTraverse(callback, texUnit.texByTarget,
+                                "state.mTexUnits[].texByTarget", flags);
+  }
+}
+
+void ImplCycleCollectionUnlink(std::shared_ptr<webgl::NotLostData>& field) {
+  if (!field) return;
+  const auto keepAlive = field;
+  keepAlive->extensions = {};
+  keepAlive->state = {};
+  field = nullptr;
+}
+
+// -----------------------------------------------------
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(WebGLBufferJS)
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(WebGLFramebufferJS, mAttachments)
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(WebGLProgramJS, mNextLink_Shaders)
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(WebGLQueryJS)
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(WebGLRenderbufferJS)
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(WebGLSamplerJS)
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(WebGLShaderJS)
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(WebGLSyncJS)
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(WebGLTextureJS)
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(WebGLTransformFeedbackJS, mAttribBuffers,
+                                      mActiveProgram)
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(WebGLUniformLocationJS)
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(WebGLVertexArrayJS, mIndexBuffer,
+                                      mAttribBuffers)
+
+// -
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ClientWebGLContext)
+  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+  NS_INTERFACE_MAP_ENTRY(nsICanvasRenderingContextInternal)
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(ClientWebGLContext)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(ClientWebGLContext)
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_WEAK_PTR(
+    ClientWebGLContext, mExtLoseContext, mNotLost,
+    // Don't forget nsICanvasRenderingContextInternal:
+    mCanvasElement, mOffscreenCanvas)
+
+// -----------------------------
+
+}  // namespace mozilla