Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 1704 insertions, 0 deletions

diff --git a/dom/canvas/WebGLFramebuffer.cpp b/dom/canvas/WebGLFramebuffer.cpp
new file mode 100644
index 0000000000..108d2178cc
--- /dev/null
+++ b/dom/canvas/WebGLFramebuffer.cpp
@@ -0,0 +1,1704 @@
+/* -*- 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 "WebGLFramebuffer.h"
+
+// You know it's going to be fun when these two show up:
+#include <algorithm>
+#include <iterator>
+
+#include "GLBlitHelper.h"
+#include "GLContext.h"
+#include "GLScreenBuffer.h"
+#include "MozFramebuffer.h"
+#include "mozilla/dom/WebGLRenderingContextBinding.h"
+#include "mozilla/IntegerRange.h"
+#include "nsPrintfCString.h"
+#include "WebGLContext.h"
+#include "WebGLContextUtils.h"
+#include "WebGLExtensions.h"
+#include "WebGLFormats.h"
+#include "WebGLRenderbuffer.h"
+#include "WebGLTexture.h"
+
+namespace mozilla {
+
+static bool ShouldDeferAttachment(const WebGLContext* const webgl,
+                                  const GLenum attachPoint) {
+  if (webgl->IsWebGL2()) return false;
+
+  switch (attachPoint) {
+    case LOCAL_GL_DEPTH_ATTACHMENT:
+    case LOCAL_GL_STENCIL_ATTACHMENT:
+    case LOCAL_GL_DEPTH_STENCIL_ATTACHMENT:
+      return true;
+    default:
+      return false;
+  }
+}
+
+WebGLFBAttachPoint::WebGLFBAttachPoint() = default;
+WebGLFBAttachPoint::WebGLFBAttachPoint(WebGLFBAttachPoint&) = default;
+
+WebGLFBAttachPoint::WebGLFBAttachPoint(const WebGLContext* const webgl,
+                                       const GLenum attachmentPoint)
+    : mAttachmentPoint(attachmentPoint),
+      mDeferAttachment(ShouldDeferAttachment(webgl, mAttachmentPoint)) {}
+
+WebGLFBAttachPoint::~WebGLFBAttachPoint() {
+  MOZ_ASSERT(!mRenderbufferPtr);
+  MOZ_ASSERT(!mTexturePtr);
+}
+
+void WebGLFBAttachPoint::Clear() { Set(nullptr, {}); }
+
+void WebGLFBAttachPoint::Set(gl::GLContext* const gl,
+                             const webgl::FbAttachInfo& toAttach) {
+  mRenderbufferPtr = toAttach.rb;
+  mTexturePtr = toAttach.tex;
+  mTexImageLayer = AssertedCast<uint32_t>(toAttach.zLayer);
+  mTexImageZLayerCount = AssertedCast<uint8_t>(toAttach.zLayerCount);
+  mTexImageLevel = AssertedCast<uint8_t>(toAttach.mipLevel);
+  mIsMultiview = toAttach.isMultiview;
+
+  if (gl && !mDeferAttachment) {
+    DoAttachment(gl);
+  }
+}
+
+const webgl::ImageInfo* WebGLFBAttachPoint::GetImageInfo() const {
+  if (mTexturePtr) {
+    const auto target = Texture()->Target();
+    uint8_t face = 0;
+    if (target == LOCAL_GL_TEXTURE_CUBE_MAP) {
+      face = Layer() % 6;
+    }
+    return &mTexturePtr->ImageInfoAtFace(face, mTexImageLevel);
+  }
+  if (mRenderbufferPtr) return &mRenderbufferPtr->ImageInfo();
+  return nullptr;
+}
+
+bool WebGLFBAttachPoint::IsComplete(WebGLContext* webgl,
+                                    nsCString* const out_info) const {
+  MOZ_ASSERT(HasAttachment());
+
+  const auto fnWriteErrorInfo = [&](const char* const text) {
+    WebGLContext::EnumName(mAttachmentPoint, out_info);
+    out_info->AppendLiteral(": ");
+    out_info->AppendASCII(text);
+  };
+
+  const auto& imageInfo = *GetImageInfo();
+  if (!imageInfo.mWidth || !imageInfo.mHeight) {
+    fnWriteErrorInfo("Attachment has no width or height.");
+    return false;
+  }
+  MOZ_ASSERT(imageInfo.IsDefined());
+
+  const auto& tex = Texture();
+  if (tex) {
+    // ES 3.0 spec, pg 213 has giant blocks of text that bake down to requiring
+    // that attached *non-immutable* tex images are within the valid mip-levels
+    // of the texture. We still need to check immutable textures though, because
+    // checking completeness is also when we zero invalidated/no-data tex
+    // images.
+    const auto attachedMipLevel = MipLevel();
+
+    const bool withinValidMipLevels = [&]() {
+      const bool ensureInit = false;
+      const auto texCompleteness = tex->CalcCompletenessInfo(ensureInit);
+      if (!texCompleteness) return false;  // OOM
+
+      if (tex->Immutable()) {
+        // Immutable textures can attach a level that's not valid for sampling.
+        // It still has to exist though!
+        return attachedMipLevel < tex->ImmutableLevelCount();
+      }
+
+      // Base level must be complete.
+      if (!texCompleteness->levels) return false;
+
+      const auto baseLevel = tex->Es3_level_base();
+      if (attachedMipLevel == baseLevel) return true;
+
+      // If not base level, must be mip-complete and within mips.
+      if (!texCompleteness->mipmapComplete) return false;
+      const auto maxLevel = baseLevel + texCompleteness->levels - 1;
+      return baseLevel <= attachedMipLevel && attachedMipLevel <= maxLevel;
+    }();
+    if (!withinValidMipLevels) {
+      fnWriteErrorInfo("Attached mip level is invalid for texture.");
+      return false;
+    }
+
+    const auto& levelInfo = tex->ImageInfoAtFace(0, attachedMipLevel);
+    const auto faceDepth = levelInfo.mDepth * tex->FaceCount();
+    const bool withinValidZLayers = Layer() + ZLayerCount() - 1 < faceDepth;
+    if (!withinValidZLayers) {
+      fnWriteErrorInfo("Attached z layer is invalid for texture.");
+      return false;
+    }
+  }
+
+  const auto& formatUsage = imageInfo.mFormat;
+  if (!formatUsage->IsRenderable()) {
+    const auto info = nsPrintfCString(
+        "Attachment has an effective format of %s,"
+        " which is not renderable.",
+        formatUsage->format->name);
+    fnWriteErrorInfo(info.BeginReading());
+    return false;
+  }
+  if (!formatUsage->IsExplicitlyRenderable()) {
+    webgl->WarnIfImplicit(formatUsage->GetExtensionID());
+  }
+
+  const auto format = formatUsage->format;
+
+  bool hasRequiredBits;
+
+  switch (mAttachmentPoint) {
+    case LOCAL_GL_DEPTH_ATTACHMENT:
+      hasRequiredBits = format->d;
+      break;
+
+    case LOCAL_GL_STENCIL_ATTACHMENT:
+      hasRequiredBits = format->s;
+      break;
+
+    case LOCAL_GL_DEPTH_STENCIL_ATTACHMENT:
+      MOZ_ASSERT(!webgl->IsWebGL2());
+      hasRequiredBits = (format->d && format->s);
+      break;
+
+    default:
+      MOZ_ASSERT(mAttachmentPoint >= LOCAL_GL_COLOR_ATTACHMENT0);
+      hasRequiredBits = format->IsColorFormat();
+      break;
+  }
+
+  if (!hasRequiredBits) {
+    fnWriteErrorInfo(
+        "Attachment's format is missing required color/depth/stencil"
+        " bits.");
+    return false;
+  }
+
+  if (!webgl->IsWebGL2()) {
+    bool hasSurplusPlanes = false;
+
+    switch (mAttachmentPoint) {
+      case LOCAL_GL_DEPTH_ATTACHMENT:
+        hasSurplusPlanes = format->s;
+        break;
+
+      case LOCAL_GL_STENCIL_ATTACHMENT:
+        hasSurplusPlanes = format->d;
+        break;
+    }
+
+    if (hasSurplusPlanes) {
+      fnWriteErrorInfo(
+          "Attachment has depth or stencil bits when it shouldn't.");
+      return false;
+    }
+  }
+
+  return true;
+}
+
+void WebGLFBAttachPoint::DoAttachment(gl::GLContext* const gl) const {
+  if (Renderbuffer()) {
+    Renderbuffer()->DoFramebufferRenderbuffer(mAttachmentPoint);
+    return;
+  }
+
+  if (!Texture()) {
+    MOZ_ASSERT(mAttachmentPoint != LOCAL_GL_DEPTH_STENCIL_ATTACHMENT);
+    // WebGL 2 doesn't have a real attachment for this, and WebGL 1 is defered
+    // and only DoAttachment if HasAttachment.
+
+    gl->fFramebufferRenderbuffer(LOCAL_GL_FRAMEBUFFER, mAttachmentPoint,
+                                 LOCAL_GL_RENDERBUFFER, 0);
+    return;
+  }
+
+  const auto& texName = Texture()->mGLName;
+
+  switch (Texture()->Target().get()) {
+    case LOCAL_GL_TEXTURE_2D:
+    case LOCAL_GL_TEXTURE_CUBE_MAP: {
+      TexImageTarget imageTarget = LOCAL_GL_TEXTURE_2D;
+      if (Texture()->Target() == LOCAL_GL_TEXTURE_CUBE_MAP) {
+        imageTarget = LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_X + Layer();
+      }
+
+      if (mAttachmentPoint == LOCAL_GL_DEPTH_STENCIL_ATTACHMENT) {
+        gl->fFramebufferTexture2D(LOCAL_GL_FRAMEBUFFER,
+                                  LOCAL_GL_DEPTH_ATTACHMENT, imageTarget.get(),
+                                  texName, MipLevel());
+        gl->fFramebufferTexture2D(LOCAL_GL_FRAMEBUFFER,
+                                  LOCAL_GL_STENCIL_ATTACHMENT,
+                                  imageTarget.get(), texName, MipLevel());
+      } else {
+        gl->fFramebufferTexture2D(LOCAL_GL_FRAMEBUFFER, mAttachmentPoint,
+                                  imageTarget.get(), texName, MipLevel());
+      }
+      break;
+    }
+
+    case LOCAL_GL_TEXTURE_2D_ARRAY:
+    case LOCAL_GL_TEXTURE_3D:
+      if (ZLayerCount() != 1) {
+        gl->fFramebufferTextureMultiview(LOCAL_GL_FRAMEBUFFER, mAttachmentPoint,
+                                         texName, MipLevel(), Layer(),
+                                         ZLayerCount());
+      } else {
+        gl->fFramebufferTextureLayer(LOCAL_GL_FRAMEBUFFER, mAttachmentPoint,
+                                     texName, MipLevel(), Layer());
+      }
+      break;
+  }
+}
+
+Maybe<double> WebGLFBAttachPoint::GetParameter(WebGLContext* webgl,
+                                               GLenum attachment,
+                                               GLenum pname) const {
+  if (!HasAttachment()) {
+    // Divergent between GLES 3 and 2.
+
+    // GLES 2.0.25 p127:
+    //   "If the value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE is NONE, then
+    //   querying any other pname will generate INVALID_ENUM."
+
+    // GLES 3.0.4 p240:
+    //   "If the value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE is NONE, no
+    //   framebuffer is bound to target. In this case querying pname
+    //   FRAMEBUFFER_ATTACHMENT_OBJECT_NAME will return zero, and all other
+    //   queries will generate an INVALID_OPERATION error."
+    switch (pname) {
+      case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
+        return Some(LOCAL_GL_NONE);
+
+      case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME:
+        if (webgl->IsWebGL2()) return Nothing();
+
+        break;
+
+      default:
+        break;
+    }
+    nsCString attachmentName;
+    WebGLContext::EnumName(attachment, &attachmentName);
+    if (webgl->IsWebGL2()) {
+      webgl->ErrorInvalidOperation("No attachment at %s.",
+                                   attachmentName.BeginReading());
+    } else {
+      webgl->ErrorInvalidEnum("No attachment at %s.",
+                              attachmentName.BeginReading());
+    }
+    return Nothing();
+  }
+
+  bool isPNameValid = false;
+  switch (pname) {
+    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE:
+      return Some(mTexturePtr ? LOCAL_GL_TEXTURE : LOCAL_GL_RENDERBUFFER);
+
+      //////
+
+    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL:
+      if (mTexturePtr) return Some(AssertedCast<uint32_t>(MipLevel()));
+      break;
+
+    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE:
+      if (mTexturePtr) {
+        GLenum face = 0;
+        if (mTexturePtr->Target() == LOCAL_GL_TEXTURE_CUBE_MAP) {
+          face = LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_X + Layer();
+        }
+        return Some(face);
+      }
+      break;
+
+      //////
+
+    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER:
+      if (webgl->IsWebGL2()) {
+        return Some(AssertedCast<int32_t>(Layer()));
+      }
+      break;
+
+    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR:
+      if (webgl->IsExtensionEnabled(WebGLExtensionID::OVR_multiview2)) {
+        return Some(AssertedCast<int32_t>(Layer()));
+      }
+      break;
+
+    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR:
+      if (webgl->IsExtensionEnabled(WebGLExtensionID::OVR_multiview2)) {
+        return Some(AssertedCast<uint32_t>(ZLayerCount()));
+      }
+      break;
+
+      //////
+
+    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
+    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
+    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
+    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
+    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
+    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
+    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:
+      isPNameValid = webgl->IsWebGL2();
+      break;
+
+    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING:
+      isPNameValid = (webgl->IsWebGL2() ||
+                      webgl->IsExtensionEnabled(WebGLExtensionID::EXT_sRGB));
+      break;
+  }
+
+  if (!isPNameValid) {
+    webgl->ErrorInvalidEnum("Invalid pname: 0x%04x", pname);
+    return Nothing();
+  }
+
+  const auto& imageInfo = *GetImageInfo();
+  const auto& usage = imageInfo.mFormat;
+  if (!usage) {
+    if (pname == LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING)
+      return Some(LOCAL_GL_LINEAR);
+
+    return Nothing();
+  }
+
+  auto format = usage->format;
+
+  GLint ret = 0;
+  switch (pname) {
+    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE:
+      ret = format->r;
+      break;
+    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE:
+      ret = format->g;
+      break;
+    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE:
+      ret = format->b;
+      break;
+    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE:
+      ret = format->a;
+      break;
+    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE:
+      ret = format->d;
+      break;
+    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE:
+      ret = format->s;
+      break;
+
+    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING:
+      ret = (format->isSRGB ? LOCAL_GL_SRGB : LOCAL_GL_LINEAR);
+      break;
+
+    case LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE:
+      MOZ_ASSERT(attachment != LOCAL_GL_DEPTH_STENCIL_ATTACHMENT);
+
+      if (format->unsizedFormat == webgl::UnsizedFormat::DEPTH_STENCIL) {
+        MOZ_ASSERT(attachment == LOCAL_GL_DEPTH_ATTACHMENT ||
+                   attachment == LOCAL_GL_STENCIL_ATTACHMENT);
+
+        if (attachment == LOCAL_GL_DEPTH_ATTACHMENT) {
+          switch (format->effectiveFormat) {
+            case webgl::EffectiveFormat::DEPTH24_STENCIL8:
+              format =
+                  webgl::GetFormat(webgl::EffectiveFormat::DEPTH_COMPONENT24);
+              break;
+            case webgl::EffectiveFormat::DEPTH32F_STENCIL8:
+              format =
+                  webgl::GetFormat(webgl::EffectiveFormat::DEPTH_COMPONENT32F);
+              break;
+            default:
+              MOZ_ASSERT(false, "no matched DS format");
+              break;
+          }
+        } else if (attachment == LOCAL_GL_STENCIL_ATTACHMENT) {
+          switch (format->effectiveFormat) {
+            case webgl::EffectiveFormat::DEPTH24_STENCIL8:
+            case webgl::EffectiveFormat::DEPTH32F_STENCIL8:
+              format = webgl::GetFormat(webgl::EffectiveFormat::STENCIL_INDEX8);
+              break;
+            default:
+              MOZ_ASSERT(false, "no matched DS format");
+              break;
+          }
+        }
+      }
+
+      switch (format->componentType) {
+        case webgl::ComponentType::Int:
+          ret = LOCAL_GL_INT;
+          break;
+        case webgl::ComponentType::UInt:
+          ret = LOCAL_GL_UNSIGNED_INT;
+          break;
+        case webgl::ComponentType::NormInt:
+          ret = LOCAL_GL_SIGNED_NORMALIZED;
+          break;
+        case webgl::ComponentType::NormUInt:
+          ret = LOCAL_GL_UNSIGNED_NORMALIZED;
+          break;
+        case webgl::ComponentType::Float:
+          ret = LOCAL_GL_FLOAT;
+          break;
+      }
+      break;
+
+    default:
+      MOZ_ASSERT(false, "Missing case.");
+      break;
+  }
+
+  return Some(ret);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+// WebGLFramebuffer
+
+WebGLFramebuffer::WebGLFramebuffer(WebGLContext* webgl, GLuint fbo)
+    : WebGLContextBoundObject(webgl),
+      mGLName(fbo),
+      mDepthAttachment(webgl, LOCAL_GL_DEPTH_ATTACHMENT),
+      mStencilAttachment(webgl, LOCAL_GL_STENCIL_ATTACHMENT),
+      mDepthStencilAttachment(webgl, LOCAL_GL_DEPTH_STENCIL_ATTACHMENT) {
+  mAttachments.push_back(&mDepthAttachment);
+  mAttachments.push_back(&mStencilAttachment);
+
+  if (!webgl->IsWebGL2()) {
+    // Only WebGL1 has a separate depth+stencil attachment point.
+    mAttachments.push_back(&mDepthStencilAttachment);
+  }
+
+  size_t i = 0;
+  for (auto& cur : mColorAttachments) {
+    new (&cur) WebGLFBAttachPoint(webgl, LOCAL_GL_COLOR_ATTACHMENT0 + i);
+    i++;
+
+    mAttachments.push_back(&cur);
+  }
+
+  mColorDrawBuffers.push_back(&mColorAttachments[0]);
+  mColorReadBuffer = &mColorAttachments[0];
+}
+
+WebGLFramebuffer::WebGLFramebuffer(WebGLContext* webgl,
+                                   UniquePtr<gl::MozFramebuffer> fbo)
+    : WebGLContextBoundObject(webgl),
+      mGLName(fbo->mFB),
+      mOpaque(std::move(fbo)),
+      mColorReadBuffer(nullptr) {
+  // Opaque Framebuffer is guaranteed to be complete at this point.
+  // Cache the Completeness info.
+  CompletenessInfo info;
+  info.width = mOpaque->mSize.width;
+  info.height = mOpaque->mSize.height;
+  info.zLayerCount = 1;
+  info.isMultiview = false;
+
+  mCompletenessInfo = Some(std::move(info));
+}
+
+WebGLFramebuffer::~WebGLFramebuffer() {
+  InvalidateCaches();
+
+  mDepthAttachment.Clear();
+  mStencilAttachment.Clear();
+  mDepthStencilAttachment.Clear();
+
+  for (auto& cur : mColorAttachments) {
+    cur.Clear();
+  }
+
+  if (!mContext) return;
+  // If opaque, fDeleteFramebuffers is called in the destructor of
+  // MozFramebuffer.
+  if (!mOpaque) {
+    mContext->gl->fDeleteFramebuffers(1, &mGLName);
+  }
+}
+
+////
+
+Maybe<WebGLFBAttachPoint*> WebGLFramebuffer::GetColorAttachPoint(
+    GLenum attachPoint) {
+  if (attachPoint == LOCAL_GL_NONE) return Some<WebGLFBAttachPoint*>(nullptr);
+
+  if (attachPoint < LOCAL_GL_COLOR_ATTACHMENT0) return Nothing();
+
+  const size_t colorId = attachPoint - LOCAL_GL_COLOR_ATTACHMENT0;
+
+  MOZ_ASSERT(mContext->Limits().maxColorDrawBuffers <= webgl::kMaxDrawBuffers);
+  if (colorId >= mContext->MaxValidDrawBuffers()) return Nothing();
+
+  return Some(&mColorAttachments[colorId]);
+}
+
+Maybe<WebGLFBAttachPoint*> WebGLFramebuffer::GetAttachPoint(
+    GLenum attachPoint) {
+  switch (attachPoint) {
+    case LOCAL_GL_DEPTH_STENCIL_ATTACHMENT:
+      return Some(&mDepthStencilAttachment);
+
+    case LOCAL_GL_DEPTH_ATTACHMENT:
+      return Some(&mDepthAttachment);
+
+    case LOCAL_GL_STENCIL_ATTACHMENT:
+      return Some(&mStencilAttachment);
+
+    default:
+      return GetColorAttachPoint(attachPoint);
+  }
+}
+
+void WebGLFramebuffer::DetachTexture(const WebGLTexture* tex) {
+  for (const auto& attach : mAttachments) {
+    if (attach->Texture() == tex) {
+      attach->Clear();
+    }
+  }
+  InvalidateCaches();
+}
+
+void WebGLFramebuffer::DetachRenderbuffer(const WebGLRenderbuffer* rb) {
+  for (const auto& attach : mAttachments) {
+    if (attach->Renderbuffer() == rb) {
+      attach->Clear();
+    }
+  }
+  InvalidateCaches();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Completeness
+
+bool WebGLFramebuffer::HasDuplicateAttachments() const {
+  std::set<WebGLFBAttachPoint::Ordered> uniqueAttachSet;
+
+  for (const auto& attach : mColorAttachments) {
+    if (!attach.HasAttachment()) continue;
+
+    const WebGLFBAttachPoint::Ordered ordered(attach);
+
+    const bool didInsert = uniqueAttachSet.insert(ordered).second;
+    if (!didInsert) return true;
+  }
+
+  return false;
+}
+
+bool WebGLFramebuffer::HasDefinedAttachments() const {
+  bool hasAttachments = false;
+  for (const auto& attach : mAttachments) {
+    hasAttachments |= attach->HasAttachment();
+  }
+  return hasAttachments;
+}
+
+bool WebGLFramebuffer::HasIncompleteAttachments(
+    nsCString* const out_info) const {
+  bool hasIncomplete = false;
+  for (const auto& cur : mAttachments) {
+    if (!cur->HasAttachment())
+      continue;  // Not defined, so can't count as incomplete.
+
+    hasIncomplete |= !cur->IsComplete(mContext, out_info);
+  }
+  return hasIncomplete;
+}
+
+bool WebGLFramebuffer::AllImageRectsMatch() const {
+  MOZ_ASSERT(HasDefinedAttachments());
+  DebugOnly<nsCString> fbStatusInfo;
+  MOZ_ASSERT(!HasIncompleteAttachments(&fbStatusInfo));
+
+  bool needsInit = true;
+  uint32_t width = 0;
+  uint32_t height = 0;
+
+  bool hasMismatch = false;
+  for (const auto& attach : mAttachments) {
+    const auto& imageInfo = attach->GetImageInfo();
+    if (!imageInfo) continue;
+
+    const auto& curWidth = imageInfo->mWidth;
+    const auto& curHeight = imageInfo->mHeight;
+
+    if (needsInit) {
+      needsInit = false;
+      width = curWidth;
+      height = curHeight;
+      continue;
+    }
+
+    hasMismatch |= (curWidth != width || curHeight != height);
+  }
+  return !hasMismatch;
+}
+
+bool WebGLFramebuffer::AllImageSamplesMatch() const {
+  MOZ_ASSERT(HasDefinedAttachments());
+  DebugOnly<nsCString> fbStatusInfo;
+  MOZ_ASSERT(!HasIncompleteAttachments(&fbStatusInfo));
+
+  bool needsInit = true;
+  uint32_t samples = 0;
+
+  bool hasMismatch = false;
+  for (const auto& attach : mAttachments) {
+    const auto& imageInfo = attach->GetImageInfo();
+    if (!imageInfo) continue;
+
+    const auto& curSamples = imageInfo->mSamples;
+
+    if (needsInit) {
+      needsInit = false;
+      samples = curSamples;
+      continue;
+    }
+
+    hasMismatch |= (curSamples != samples);
+  };
+  return !hasMismatch;
+}
+
+FBStatus WebGLFramebuffer::PrecheckFramebufferStatus(
+    nsCString* const out_info) const {
+  MOZ_ASSERT(mContext->mBoundDrawFramebuffer == this ||
+             mContext->mBoundReadFramebuffer == this);
+  if (!HasDefinedAttachments())
+    return LOCAL_GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT;  // No
+                                                                // attachments
+
+  if (HasIncompleteAttachments(out_info))
+    return LOCAL_GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
+
+  if (!AllImageRectsMatch())
+    return LOCAL_GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS;  // Inconsistent sizes
+
+  if (!AllImageSamplesMatch())
+    return LOCAL_GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE;  // Inconsistent samples
+
+  if (HasDuplicateAttachments()) return LOCAL_GL_FRAMEBUFFER_UNSUPPORTED;
+
+  if (mContext->IsWebGL2()) {
+    MOZ_ASSERT(!mDepthStencilAttachment.HasAttachment());
+    if (mDepthAttachment.HasAttachment() &&
+        mStencilAttachment.HasAttachment()) {
+      if (!mDepthAttachment.IsEquivalentForFeedback(mStencilAttachment))
+        return LOCAL_GL_FRAMEBUFFER_UNSUPPORTED;
+    }
+  } else {
+    const auto depthOrStencilCount =
+        int(mDepthAttachment.HasAttachment()) +
+        int(mStencilAttachment.HasAttachment()) +
+        int(mDepthStencilAttachment.HasAttachment());
+    if (depthOrStencilCount > 1) return LOCAL_GL_FRAMEBUFFER_UNSUPPORTED;
+  }
+
+  {
+    const WebGLFBAttachPoint* example = nullptr;
+    for (const auto& x : mAttachments) {
+      if (!x->HasAttachment()) continue;
+      if (!example) {
+        example = x;
+        continue;
+      }
+      if (x->ZLayerCount() != example->ZLayerCount()) {
+        return LOCAL_GL_FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR;
+      }
+    }
+  }
+
+  return LOCAL_GL_FRAMEBUFFER_COMPLETE;
+}
+
+////////////////////////////////////////
+// Validation
+
+bool WebGLFramebuffer::ValidateAndInitAttachments(
+    const GLenum incompleteFbError) const {
+  MOZ_ASSERT(mContext->mBoundDrawFramebuffer == this ||
+             mContext->mBoundReadFramebuffer == this);
+
+  const auto fbStatus = CheckFramebufferStatus();
+  if (fbStatus == LOCAL_GL_FRAMEBUFFER_COMPLETE) return true;
+
+  mContext->GenerateError(incompleteFbError, "Framebuffer must be complete.");
+  return false;
+}
+
+bool WebGLFramebuffer::ValidateClearBufferType(
+    GLenum buffer, uint32_t drawBuffer,
+    const webgl::AttribBaseType funcType) const {
+  if (buffer != LOCAL_GL_COLOR) return true;
+
+  const auto& attach = mColorAttachments[drawBuffer];
+  const auto& imageInfo = attach.GetImageInfo();
+  if (!imageInfo) return true;
+
+  if (!count(mColorDrawBuffers.begin(), mColorDrawBuffers.end(), &attach))
+    return true;  // DRAW_BUFFERi set to NONE.
+
+  auto attachType = webgl::AttribBaseType::Float;
+  switch (imageInfo->mFormat->format->componentType) {
+    case webgl::ComponentType::Int:
+      attachType = webgl::AttribBaseType::Int;
+      break;
+    case webgl::ComponentType::UInt:
+      attachType = webgl::AttribBaseType::Uint;
+      break;
+    default:
+      break;
+  }
+
+  if (attachType != funcType) {
+    mContext->ErrorInvalidOperation(
+        "This attachment is of type %s, but"
+        " this function is of type %s.",
+        ToString(attachType), ToString(funcType));
+    return false;
+  }
+
+  return true;
+}
+
+bool WebGLFramebuffer::ValidateForColorRead(
+    const webgl::FormatUsageInfo** const out_format, uint32_t* const out_width,
+    uint32_t* const out_height) const {
+  if (!mColorReadBuffer) {
+    mContext->ErrorInvalidOperation("READ_BUFFER must not be NONE.");
+    return false;
+  }
+
+  if (mColorReadBuffer->ZLayerCount() > 1) {
+    mContext->GenerateError(LOCAL_GL_INVALID_FRAMEBUFFER_OPERATION,
+                            "The READ_BUFFER attachment has multiple views.");
+    return false;
+  }
+
+  const auto& imageInfo = mColorReadBuffer->GetImageInfo();
+  if (!imageInfo) {
+    mContext->ErrorInvalidOperation(
+        "The READ_BUFFER attachment is not defined.");
+    return false;
+  }
+
+  if (imageInfo->mSamples) {
+    mContext->ErrorInvalidOperation(
+        "The READ_BUFFER attachment is multisampled.");
+    return false;
+  }
+
+  *out_format = imageInfo->mFormat;
+  *out_width = imageInfo->mWidth;
+  *out_height = imageInfo->mHeight;
+  return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Resolution and caching
+
+void WebGLFramebuffer::DoDeferredAttachments() const {
+  if (mContext->IsWebGL2()) return;
+
+  const auto& gl = mContext->gl;
+  gl->fFramebufferRenderbuffer(LOCAL_GL_FRAMEBUFFER, LOCAL_GL_DEPTH_ATTACHMENT,
+                               LOCAL_GL_RENDERBUFFER, 0);
+  gl->fFramebufferRenderbuffer(LOCAL_GL_FRAMEBUFFER,
+                               LOCAL_GL_STENCIL_ATTACHMENT,
+                               LOCAL_GL_RENDERBUFFER, 0);
+
+  const auto fn = [&](const WebGLFBAttachPoint& attach) {
+    MOZ_ASSERT(attach.mDeferAttachment);
+    if (attach.HasAttachment()) {
+      attach.DoAttachment(gl);
+    }
+  };
+  // Only one of these will have an attachment.
+  fn(mDepthAttachment);
+  fn(mStencilAttachment);
+  fn(mDepthStencilAttachment);
+}
+
+void WebGLFramebuffer::ResolveAttachmentData() const {
+  // GLES 3.0.5 p188:
+  //   The result of clearing integer color buffers with `Clear` is undefined.
+
+  // Two different approaches:
+  // On WebGL 2, we have glClearBuffer, and *must* use it for integer buffers,
+  // so let's just use it for all the buffers. One WebGL 1, we might not have
+  // glClearBuffer,
+
+  // WebGL 1 is easier, because we can just call glClear, possibly with
+  // glDrawBuffers.
+
+  const auto& gl = mContext->gl;
+
+  const webgl::ScopedPrepForResourceClear scopedPrep(*mContext);
+
+  if (mContext->IsWebGL2()) {
+    const uint32_t uiZeros[4] = {};
+    const int32_t iZeros[4] = {};
+    const float fZeros[4] = {};
+    const float fOne[] = {1.0f};
+
+    for (const auto& cur : mAttachments) {
+      const auto& imageInfo = cur->GetImageInfo();
+      if (!imageInfo || !imageInfo->mUninitializedSlices)
+        continue;  // Nothing attached, or already has data.
+
+      const auto fnClearBuffer = [&]() {
+        const auto& format = imageInfo->mFormat->format;
+        MOZ_ASSERT(format->estimatedBytesPerPixel <= sizeof(uiZeros));
+        MOZ_ASSERT(format->estimatedBytesPerPixel <= sizeof(iZeros));
+        MOZ_ASSERT(format->estimatedBytesPerPixel <= sizeof(fZeros));
+
+        switch (cur->mAttachmentPoint) {
+          case LOCAL_GL_DEPTH_ATTACHMENT:
+            gl->fClearBufferfv(LOCAL_GL_DEPTH, 0, fOne);
+            break;
+          case LOCAL_GL_STENCIL_ATTACHMENT:
+            gl->fClearBufferiv(LOCAL_GL_STENCIL, 0, iZeros);
+            break;
+          default:
+            MOZ_ASSERT(cur->mAttachmentPoint !=
+                       LOCAL_GL_DEPTH_STENCIL_ATTACHMENT);
+            const uint32_t drawBuffer =
+                cur->mAttachmentPoint - LOCAL_GL_COLOR_ATTACHMENT0;
+            MOZ_ASSERT(drawBuffer <= 100);
+            switch (format->componentType) {
+              case webgl::ComponentType::Int:
+                gl->fClearBufferiv(LOCAL_GL_COLOR, drawBuffer, iZeros);
+                break;
+              case webgl::ComponentType::UInt:
+                gl->fClearBufferuiv(LOCAL_GL_COLOR, drawBuffer, uiZeros);
+                break;
+              default:
+                gl->fClearBufferfv(LOCAL_GL_COLOR, drawBuffer, fZeros);
+                break;
+            }
+        }
+      };
+
+      if (imageInfo->mDepth > 1) {
+        const auto& tex = cur->Texture();
+        const gl::ScopedFramebuffer scopedFB(gl);
+        const gl::ScopedBindFramebuffer scopedBindFB(gl, scopedFB.FB());
+        for (const auto z : IntegerRange(imageInfo->mDepth)) {
+          if ((*imageInfo->mUninitializedSlices)[z]) {
+            gl->fFramebufferTextureLayer(LOCAL_GL_FRAMEBUFFER,
+                                         cur->mAttachmentPoint, tex->mGLName,
+                                         cur->MipLevel(), z);
+            fnClearBuffer();
+          }
+        }
+      } else {
+        fnClearBuffer();
+      }
+      imageInfo->mUninitializedSlices = Nothing();
+    }
+    return;
+  }
+
+  uint32_t clearBits = 0;
+  std::vector<GLenum> drawBufferForClear;
+
+  const auto fnGather = [&](const WebGLFBAttachPoint& attach,
+                            const uint32_t attachClearBits) {
+    const auto& imageInfo = attach.GetImageInfo();
+    if (!imageInfo || !imageInfo->mUninitializedSlices) return false;
+
+    clearBits |= attachClearBits;
+    imageInfo->mUninitializedSlices = Nothing();  // Just mark it now.
+    return true;
+  };
+
+  //////
+
+  for (const auto& cur : mColorAttachments) {
+    if (fnGather(cur, LOCAL_GL_COLOR_BUFFER_BIT)) {
+      const uint32_t id = cur.mAttachmentPoint - LOCAL_GL_COLOR_ATTACHMENT0;
+      MOZ_ASSERT(id <= 100);
+      drawBufferForClear.resize(id + 1);  // Pads with zeros!
+      drawBufferForClear[id] = cur.mAttachmentPoint;
+    }
+  }
+
+  (void)fnGather(mDepthAttachment, LOCAL_GL_DEPTH_BUFFER_BIT);
+  (void)fnGather(mStencilAttachment, LOCAL_GL_STENCIL_BUFFER_BIT);
+  (void)fnGather(mDepthStencilAttachment,
+                 LOCAL_GL_DEPTH_BUFFER_BIT | LOCAL_GL_STENCIL_BUFFER_BIT);
+
+  //////
+
+  if (!clearBits) return;
+
+  if (gl->IsSupported(gl::GLFeature::draw_buffers)) {
+    gl->fDrawBuffers(drawBufferForClear.size(), drawBufferForClear.data());
+  }
+
+  gl->fClear(clearBits);
+
+  RefreshDrawBuffers();
+}
+
+WebGLFramebuffer::CompletenessInfo::~CompletenessInfo() {
+  if (!this->fb) return;
+  const auto& fb = *this->fb;
+  const auto& webgl = fb.mContext;
+  fb.mNumFBStatusInvals++;
+  if (fb.mNumFBStatusInvals > webgl->mMaxAcceptableFBStatusInvals) {
+    webgl->GeneratePerfWarning(
+        "FB was invalidated after being complete %u"
+        " times. [webgl.perf.max-acceptable-fb-status-invals]",
+        uint32_t(fb.mNumFBStatusInvals));
+  }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Entrypoints
+
+FBStatus WebGLFramebuffer::CheckFramebufferStatus() const {
+  if (MOZ_UNLIKELY(mOpaque && !mInOpaqueRAF)) {
+    // Opaque Framebuffers are considered incomplete outside of a RAF.
+    return LOCAL_GL_FRAMEBUFFER_UNSUPPORTED;
+  }
+
+  if (mCompletenessInfo) return LOCAL_GL_FRAMEBUFFER_COMPLETE;
+
+  // Ok, let's try to resolve it!
+
+  nsCString statusInfo;
+  FBStatus ret = PrecheckFramebufferStatus(&statusInfo);
+  do {
+    if (ret != LOCAL_GL_FRAMEBUFFER_COMPLETE) break;
+
+    // Looks good on our end. Let's ask the driver.
+    gl::GLContext* const gl = mContext->gl;
+
+    const ScopedFBRebinder autoFB(mContext);
+    gl->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, mGLName);
+
+    ////
+
+    DoDeferredAttachments();
+    RefreshDrawBuffers();
+    RefreshReadBuffer();
+
+    ret = gl->fCheckFramebufferStatus(LOCAL_GL_FRAMEBUFFER);
+
+    ////
+
+    if (ret != LOCAL_GL_FRAMEBUFFER_COMPLETE) {
+      const nsPrintfCString text("Bad status according to the driver: 0x%04x",
+                                 ret.get());
+      statusInfo = text;
+      break;
+    }
+
+    ResolveAttachmentData();
+
+    // Sweet, let's cache that.
+    auto info = CompletenessInfo{this};
+    mCompletenessInfo.ResetInvalidators({});
+    mCompletenessInfo.AddInvalidator(*this);
+
+    const auto fnIsFloat32 = [](const webgl::FormatInfo& info) {
+      if (info.componentType != webgl::ComponentType::Float) return false;
+      return info.r == 32;
+    };
+
+    for (const auto& cur : mAttachments) {
+      const auto& tex = cur->Texture();
+      const auto& rb = cur->Renderbuffer();
+      if (tex) {
+        mCompletenessInfo.AddInvalidator(*tex);
+        info.texAttachments.push_back(cur);
+      } else if (rb) {
+        mCompletenessInfo.AddInvalidator(*rb);
+      } else {
+        continue;
+      }
+      const auto& imageInfo = cur->GetImageInfo();
+      MOZ_ASSERT(imageInfo);
+
+      const auto maybeColorId = cur->ColorAttachmentId();
+      if (maybeColorId) {
+        const auto id = *maybeColorId;
+        info.hasAttachment[id] = true;
+        info.isAttachmentF32[id] = fnIsFloat32(*imageInfo->mFormat->format);
+      }
+
+      info.width = imageInfo->mWidth;
+      info.height = imageInfo->mHeight;
+      info.zLayerCount = cur->ZLayerCount();
+      info.isMultiview = cur->IsMultiview();
+    }
+    MOZ_ASSERT(info.width && info.height);
+    mCompletenessInfo = Some(std::move(info));
+    info.fb = nullptr;  // Don't trigger the invalidation warning.
+    return LOCAL_GL_FRAMEBUFFER_COMPLETE;
+  } while (false);
+
+  MOZ_ASSERT(ret != LOCAL_GL_FRAMEBUFFER_COMPLETE);
+  mContext->GenerateWarning("Framebuffer not complete. (status: 0x%04x) %s",
+                            ret.get(), statusInfo.BeginReading());
+  return ret;
+}
+
+////
+
+void WebGLFramebuffer::RefreshDrawBuffers() const {
+  const auto& gl = mContext->gl;
+  if (!gl->IsSupported(gl::GLFeature::draw_buffers)) return;
+
+  // Prior to GL4.1, having a no-image FB attachment that's selected by
+  // DrawBuffers yields a framebuffer status of
+  // FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER. We could workaround this only on
+  // affected versions, but it's easier be unconditional.
+  std::vector<GLenum> driverBuffers(mContext->Limits().maxColorDrawBuffers,
+                                    LOCAL_GL_NONE);
+  for (const auto& attach : mColorDrawBuffers) {
+    if (attach->HasAttachment()) {
+      const uint32_t index =
+          attach->mAttachmentPoint - LOCAL_GL_COLOR_ATTACHMENT0;
+      driverBuffers[index] = attach->mAttachmentPoint;
+    }
+  }
+
+  gl->fBindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER, mGLName);
+  gl->fDrawBuffers(driverBuffers.size(), driverBuffers.data());
+}
+
+void WebGLFramebuffer::RefreshReadBuffer() const {
+  const auto& gl = mContext->gl;
+  if (!gl->IsSupported(gl::GLFeature::read_buffer)) return;
+
+  // Prior to GL4.1, having a no-image FB attachment that's selected by
+  // ReadBuffer yields a framebuffer status of
+  // FRAMEBUFFER_INCOMPLETE_READ_BUFFER. We could workaround this only on
+  // affected versions, but it's easier be unconditional.
+  GLenum driverBuffer = LOCAL_GL_NONE;
+  if (mColorReadBuffer && mColorReadBuffer->HasAttachment()) {
+    driverBuffer = mColorReadBuffer->mAttachmentPoint;
+  }
+
+  gl->fBindFramebuffer(LOCAL_GL_READ_FRAMEBUFFER, mGLName);
+  gl->fReadBuffer(driverBuffer);
+}
+
+////
+
+void WebGLFramebuffer::DrawBuffers(const std::vector<GLenum>& buffers) {
+  if (buffers.size() > mContext->MaxValidDrawBuffers()) {
+    // "An INVALID_VALUE error is generated if `n` is greater than
+    // MAX_DRAW_BUFFERS."
+    mContext->ErrorInvalidValue(
+        "`buffers` must have a length <="
+        " MAX_DRAW_BUFFERS.");
+    return;
+  }
+
+  std::vector<const WebGLFBAttachPoint*> newColorDrawBuffers;
+  newColorDrawBuffers.reserve(buffers.size());
+
+  mDrawBufferEnabled.reset();
+  for (const auto i : IntegerRange(buffers.size())) {
+    // "If the GL is bound to a draw framebuffer object, the `i`th buffer listed
+    // in bufs must be COLOR_ATTACHMENTi or NONE. Specifying a buffer out of
+    // order, BACK, or COLOR_ATTACHMENTm where `m` is greater than or equal to
+    // the value of MAX_COLOR_ATTACHMENTS, will generate the error
+    // INVALID_OPERATION.
+
+    // WEBGL_draw_buffers:
+    // "The value of the MAX_COLOR_ATTACHMENTS_WEBGL parameter must be greater
+    // than or equal to that of the MAX_DRAW_BUFFERS_WEBGL parameter." This
+    // means that if buffers.Length() isn't larger than MaxDrawBuffers, it won't
+    // be larger than MaxColorAttachments.
+    const auto& cur = buffers[i];
+    if (cur == LOCAL_GL_COLOR_ATTACHMENT0 + i) {
+      const auto& attach = mColorAttachments[i];
+      newColorDrawBuffers.push_back(&attach);
+      mDrawBufferEnabled[i] = true;
+    } else if (cur != LOCAL_GL_NONE) {
+      const bool isColorEnum = (cur >= LOCAL_GL_COLOR_ATTACHMENT0 &&
+                                cur < mContext->LastColorAttachmentEnum());
+      if (cur != LOCAL_GL_BACK && !isColorEnum) {
+        mContext->ErrorInvalidEnum("Unexpected enum in buffers.");
+        return;
+      }
+
+      mContext->ErrorInvalidOperation(
+          "`buffers[i]` must be NONE or"
+          " COLOR_ATTACHMENTi.");
+      return;
+    }
+  }
+
+  ////
+
+  mColorDrawBuffers = std::move(newColorDrawBuffers);
+  RefreshDrawBuffers();  // Calls glDrawBuffers.
+}
+
+void WebGLFramebuffer::ReadBuffer(GLenum attachPoint) {
+  const auto& maybeAttach = GetColorAttachPoint(attachPoint);
+  if (!maybeAttach) {
+    const char text[] =
+        "`mode` must be a COLOR_ATTACHMENTi, for 0 <= i <"
+        " MAX_DRAW_BUFFERS.";
+    if (attachPoint == LOCAL_GL_BACK) {
+      mContext->ErrorInvalidOperation(text);
+    } else {
+      mContext->ErrorInvalidEnum(text);
+    }
+    return;
+  }
+  const auto& attach = maybeAttach.value();  // Might be nullptr.
+
+  ////
+
+  mColorReadBuffer = attach;
+  RefreshReadBuffer();  // Calls glReadBuffer.
+}
+
+////
+
+bool WebGLFramebuffer::FramebufferAttach(const GLenum attachEnum,
+                                         const webgl::FbAttachInfo& toAttach) {
+  MOZ_ASSERT(mContext->mBoundDrawFramebuffer == this ||
+             mContext->mBoundReadFramebuffer == this);
+
+  if (MOZ_UNLIKELY(mOpaque)) {
+    // An opaque framebuffer's attachments cannot be inspected or changed.
+    return false;
+  }
+
+  // `attachment`
+  const auto maybeAttach = GetAttachPoint(attachEnum);
+  if (!maybeAttach || !maybeAttach.value()) return false;
+  const auto& attach = maybeAttach.value();
+
+  const auto& gl = mContext->gl;
+  gl->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, mGLName);
+  if (mContext->IsWebGL2() && attachEnum == LOCAL_GL_DEPTH_STENCIL_ATTACHMENT) {
+    mDepthAttachment.Set(gl, toAttach);
+    mStencilAttachment.Set(gl, toAttach);
+  } else {
+    attach->Set(gl, toAttach);
+  }
+  InvalidateCaches();
+  return true;
+}
+
+Maybe<double> WebGLFramebuffer::GetAttachmentParameter(GLenum attachEnum,
+                                                       GLenum pname) {
+  const auto maybeAttach = GetAttachPoint(attachEnum);
+  if (!maybeAttach || attachEnum == LOCAL_GL_NONE) {
+    mContext->ErrorInvalidEnum(
+        "Can only query COLOR_ATTACHMENTi,"
+        " DEPTH_ATTACHMENT, DEPTH_STENCIL_ATTACHMENT, or"
+        " STENCIL_ATTACHMENT for a framebuffer.");
+    return Nothing();
+  }
+  if (MOZ_UNLIKELY(mOpaque)) {
+    mContext->ErrorInvalidOperation(
+        "An opaque framebuffer's attachments cannot be inspected or changed.");
+    return Nothing();
+  }
+  auto attach = maybeAttach.value();
+
+  if (mContext->IsWebGL2() && attachEnum == LOCAL_GL_DEPTH_STENCIL_ATTACHMENT) {
+    // There are a couple special rules for this one.
+
+    if (pname == LOCAL_GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE) {
+      mContext->ErrorInvalidOperation(
+          "Querying"
+          " FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE"
+          " against DEPTH_STENCIL_ATTACHMENT is an"
+          " error.");
+      return Nothing();
+    }
+
+    if (mDepthAttachment.Renderbuffer() != mStencilAttachment.Renderbuffer() ||
+        mDepthAttachment.Texture() != mStencilAttachment.Texture()) {
+      mContext->ErrorInvalidOperation(
+          "DEPTH_ATTACHMENT and STENCIL_ATTACHMENT"
+          " have different objects bound.");
+      return Nothing();
+    }
+
+    attach = &mDepthAttachment;
+  }
+
+  return attach->GetParameter(mContext, attachEnum, pname);
+}
+
+////////////////////
+
+static void GetBackbufferFormats(const WebGLContext* webgl,
+                                 const webgl::FormatInfo** const out_color,
+                                 const webgl::FormatInfo** const out_depth,
+                                 const webgl::FormatInfo** const out_stencil) {
+  const auto& options = webgl->Options();
+
+  const auto effFormat = (options.alpha ? webgl::EffectiveFormat::RGBA8
+                                        : webgl::EffectiveFormat::RGB8);
+  *out_color = webgl::GetFormat(effFormat);
+
+  *out_depth = nullptr;
+  *out_stencil = nullptr;
+  if (options.depth && options.stencil) {
+    *out_depth = webgl::GetFormat(webgl::EffectiveFormat::DEPTH24_STENCIL8);
+    *out_stencil = *out_depth;
+  } else {
+    if (options.depth) {
+      *out_depth = webgl::GetFormat(webgl::EffectiveFormat::DEPTH_COMPONENT16);
+    }
+    if (options.stencil) {
+      *out_stencil = webgl::GetFormat(webgl::EffectiveFormat::STENCIL_INDEX8);
+    }
+  }
+}
+
+/*static*/
+void WebGLFramebuffer::BlitFramebuffer(WebGLContext* webgl, GLint _srcX0,
+                                       GLint _srcY0, GLint _srcX1, GLint _srcY1,
+                                       GLint _dstX0, GLint _dstY0, GLint _dstX1,
+                                       GLint _dstY1, GLbitfield mask,
+                                       GLenum filter) {
+  auto srcP0 = ivec2{_srcX0, _srcY0};
+  auto srcP1 = ivec2{_srcX1, _srcY1};
+  auto dstP0 = ivec2{_dstX0, _dstY0};
+  auto dstP1 = ivec2{_dstX1, _dstY1};
+
+  const GLbitfield depthAndStencilBits =
+      LOCAL_GL_DEPTH_BUFFER_BIT | LOCAL_GL_STENCIL_BUFFER_BIT;
+  if (bool(mask & depthAndStencilBits) && filter == LOCAL_GL_LINEAR) {
+    webgl->ErrorInvalidOperation(
+        "DEPTH_BUFFER_BIT and STENCIL_BUFFER_BIT can"
+        " only be used with NEAREST filtering.");
+    return;
+  }
+
+  const auto& srcFB = webgl->mBoundReadFramebuffer;
+  const auto& dstFB = webgl->mBoundDrawFramebuffer;
+
+  ////
+  // Collect data
+
+  const auto fnGetFormat =
+      [](const WebGLFBAttachPoint& cur,
+         bool* const out_hasSamples) -> const webgl::FormatInfo* {
+    const auto& imageInfo = cur.GetImageInfo();
+    if (!imageInfo) return nullptr;  // No attachment.
+    *out_hasSamples = bool(imageInfo->mSamples);
+    return imageInfo->mFormat->format;
+  };
+
+  bool srcHasSamples = false;
+  bool srcIsFilterable = true;
+  const webgl::FormatInfo* srcColorFormat;
+  const webgl::FormatInfo* srcDepthFormat;
+  const webgl::FormatInfo* srcStencilFormat;
+  gfx::IntSize srcSize;
+
+  if (srcFB) {
+    const auto& info = *srcFB->GetCompletenessInfo();
+    if (info.zLayerCount != 1) {
+      webgl->GenerateError(
+          LOCAL_GL_INVALID_FRAMEBUFFER_OPERATION,
+          "Source framebuffer cannot have more than one multiview layer.");
+      return;
+    }
+    srcColorFormat = nullptr;
+    if (srcFB->mColorReadBuffer) {
+      const auto& imageInfo = srcFB->mColorReadBuffer->GetImageInfo();
+      if (imageInfo) {
+        srcIsFilterable &= imageInfo->mFormat->isFilterable;
+      }
+      srcColorFormat = fnGetFormat(*(srcFB->mColorReadBuffer), &srcHasSamples);
+    }
+    srcDepthFormat = fnGetFormat(srcFB->DepthAttachment(), &srcHasSamples);
+    srcStencilFormat = fnGetFormat(srcFB->StencilAttachment(), &srcHasSamples);
+    MOZ_ASSERT(!srcFB->DepthStencilAttachment().HasAttachment());
+    srcSize = {info.width, info.height};
+  } else {
+    srcHasSamples = false;  // Always false.
+
+    GetBackbufferFormats(webgl, &srcColorFormat, &srcDepthFormat,
+                         &srcStencilFormat);
+    const auto& size = webgl->DrawingBufferSize();
+    srcSize = {size.x, size.y};
+  }
+
+  ////
+
+  bool dstHasSamples = false;
+  const webgl::FormatInfo* dstDepthFormat;
+  const webgl::FormatInfo* dstStencilFormat;
+  bool dstHasColor = false;
+  bool colorFormatsMatch = true;
+  bool colorTypesMatch = true;
+  bool colorSrgbMatches = true;
+  gfx::IntSize dstSize;
+
+  const auto fnCheckColorFormat = [&](const webgl::FormatInfo* dstFormat) {
+    MOZ_ASSERT(dstFormat->r || dstFormat->g || dstFormat->b || dstFormat->a);
+    dstHasColor = true;
+    colorFormatsMatch &= (dstFormat == srcColorFormat);
+    colorTypesMatch &=
+        srcColorFormat && (dstFormat->baseType == srcColorFormat->baseType);
+    colorSrgbMatches &=
+        srcColorFormat && (dstFormat->isSRGB == srcColorFormat->isSRGB);
+  };
+
+  if (dstFB) {
+    for (const auto& cur : dstFB->mColorDrawBuffers) {
+      const auto& format = fnGetFormat(*cur, &dstHasSamples);
+      if (!format) continue;
+
+      fnCheckColorFormat(format);
+    }
+
+    dstDepthFormat = fnGetFormat(dstFB->DepthAttachment(), &dstHasSamples);
+    dstStencilFormat = fnGetFormat(dstFB->StencilAttachment(), &dstHasSamples);
+    MOZ_ASSERT(!dstFB->DepthStencilAttachment().HasAttachment());
+
+    const auto& info = *dstFB->GetCompletenessInfo();
+    if (info.isMultiview) {
+      webgl->GenerateError(
+          LOCAL_GL_INVALID_FRAMEBUFFER_OPERATION,
+          "Destination framebuffer cannot have multiview attachments.");
+      return;
+    }
+    dstSize = {info.width, info.height};
+  } else {
+    dstHasSamples = webgl->Options().antialias;
+
+    const webgl::FormatInfo* dstColorFormat;
+    GetBackbufferFormats(webgl, &dstColorFormat, &dstDepthFormat,
+                         &dstStencilFormat);
+
+    fnCheckColorFormat(dstColorFormat);
+
+    const auto& size = webgl->DrawingBufferSize();
+    dstSize = {size.x, size.y};
+  }
+
+  ////
+  // Clear unused buffer bits
+
+  if (mask & LOCAL_GL_COLOR_BUFFER_BIT && !srcColorFormat && !dstHasColor) {
+    mask ^= LOCAL_GL_COLOR_BUFFER_BIT;
+  }
+
+  if (mask & LOCAL_GL_DEPTH_BUFFER_BIT && !srcDepthFormat && !dstDepthFormat) {
+    mask ^= LOCAL_GL_DEPTH_BUFFER_BIT;
+  }
+
+  if (mask & LOCAL_GL_STENCIL_BUFFER_BIT && !srcStencilFormat &&
+      !dstStencilFormat) {
+    mask ^= LOCAL_GL_STENCIL_BUFFER_BIT;
+  }
+
+  ////
+  // Validation
+
+  if (dstHasSamples) {
+    webgl->ErrorInvalidOperation(
+        "DRAW_FRAMEBUFFER may not have multiple"
+        " samples.");
+    return;
+  }
+
+  bool requireFilterable = (filter == LOCAL_GL_LINEAR);
+  if (srcHasSamples) {
+    requireFilterable = false;  // It picks one.
+
+    if (mask & LOCAL_GL_COLOR_BUFFER_BIT && dstHasColor && !colorFormatsMatch) {
+      webgl->ErrorInvalidOperation(
+          "Color buffer formats must match if"
+          " selected, when reading from a multisampled"
+          " source.");
+      return;
+    }
+
+    if (srcP0 != dstP0 || srcP1 != dstP1) {
+      webgl->ErrorInvalidOperation(
+          "If the source is multisampled, then the"
+          " source and dest regions must match exactly.");
+      return;
+    }
+  }
+
+  // -
+
+  if (mask & LOCAL_GL_COLOR_BUFFER_BIT) {
+    if (requireFilterable && !srcIsFilterable) {
+      webgl->ErrorInvalidOperation(
+          "`filter` is LINEAR and READ_BUFFER"
+          " contains integer data.");
+      return;
+    }
+
+    if (!colorTypesMatch) {
+      webgl->ErrorInvalidOperation(
+          "Color component types (float/uint/"
+          "int) must match.");
+      return;
+    }
+  }
+
+  /* GLES 3.0.4, p199:
+   *   Calling BlitFramebuffer will result in an INVALID_OPERATION error if
+   *   mask includes DEPTH_BUFFER_BIT or STENCIL_BUFFER_BIT, and the source
+   *   and destination depth and stencil buffer formats do not match.
+   *
+   * jgilbert: The wording is such that if only DEPTH_BUFFER_BIT is specified,
+   * the stencil formats must match. This seems wrong. It could be a spec bug,
+   * or I could be missing an interaction in one of the earlier paragraphs.
+   */
+  if (mask & LOCAL_GL_DEPTH_BUFFER_BIT && dstDepthFormat &&
+      dstDepthFormat != srcDepthFormat) {
+    webgl->ErrorInvalidOperation(
+        "Depth buffer formats must match if selected.");
+    return;
+  }
+
+  if (mask & LOCAL_GL_STENCIL_BUFFER_BIT && dstStencilFormat &&
+      dstStencilFormat != srcStencilFormat) {
+    webgl->ErrorInvalidOperation(
+        "Stencil buffer formats must match if selected.");
+    return;
+  }
+
+  ////
+  // Check for feedback
+
+  if (srcFB && dstFB) {
+    const WebGLFBAttachPoint* feedback = nullptr;
+
+    if (mask & LOCAL_GL_COLOR_BUFFER_BIT) {
+      MOZ_ASSERT(srcFB->mColorReadBuffer->HasAttachment());
+      for (const auto& cur : dstFB->mColorDrawBuffers) {
+        if (srcFB->mColorReadBuffer->IsEquivalentForFeedback(*cur)) {
+          feedback = cur;
+          break;
+        }
+      }
+    }
+
+    if (mask & LOCAL_GL_DEPTH_BUFFER_BIT &&
+        srcFB->DepthAttachment().IsEquivalentForFeedback(
+            dstFB->DepthAttachment())) {
+      feedback = &dstFB->DepthAttachment();
+    }
+
+    if (mask & LOCAL_GL_STENCIL_BUFFER_BIT &&
+        srcFB->StencilAttachment().IsEquivalentForFeedback(
+            dstFB->StencilAttachment())) {
+      feedback = &dstFB->StencilAttachment();
+    }
+
+    if (feedback) {
+      webgl->ErrorInvalidOperation(
+          "Feedback detected into DRAW_FRAMEBUFFER's"
+          " 0x%04x attachment.",
+          feedback->mAttachmentPoint);
+      return;
+    }
+  } else if (!srcFB && !dstFB) {
+    webgl->ErrorInvalidOperation("Feedback with default framebuffer.");
+    return;
+  }
+
+  // -
+  // Mutually constrain src and dst rects for eldritch blits.
+
+  [&] {
+    using fvec2 = avec2<float>;  // Switch to float, because there's no perfect
+                                 // solution anyway.
+
+    const auto zero2f = fvec2{0, 0};
+    const auto srcSizef = AsVec(srcSize).StaticCast<fvec2>();
+    const auto dstSizef = AsVec(dstSize).StaticCast<fvec2>();
+
+    const auto srcP0f = srcP0.StaticCast<fvec2>();
+    const auto srcP1f = srcP1.StaticCast<fvec2>();
+    const auto dstP0f = dstP0.StaticCast<fvec2>();
+    const auto dstP1f = dstP1.StaticCast<fvec2>();
+
+    const auto srcRectDiff = srcP1f - srcP0f;
+    const auto dstRectDiff = dstP1f - dstP0f;
+
+    // Skip if zero-sized.
+    if (!srcRectDiff.x || !srcRectDiff.y || !dstRectDiff.x || !dstRectDiff.y) {
+      srcP0 = srcP1 = dstP0 = dstP1 = {0, 0};
+      return;
+    }
+
+    // Clamp the rect points
+    const auto srcQ0 = srcP0f.ClampMinMax(zero2f, srcSizef);
+    const auto srcQ1 = srcP1f.ClampMinMax(zero2f, srcSizef);
+
+    // Normalized to the [0,1] abstact copy rect
+    const auto srcQ0Norm = (srcQ0 - srcP0f) / srcRectDiff;
+    const auto srcQ1Norm = (srcQ1 - srcP0f) / srcRectDiff;
+
+    // Map into dst
+    const auto srcQ0InDst = dstP0f + srcQ0Norm * dstRectDiff;
+    const auto srcQ1InDst = dstP0f + srcQ1Norm * dstRectDiff;
+
+    // Clamp the rect points
+    const auto dstQ0 = srcQ0InDst.ClampMinMax(zero2f, dstSizef);
+    const auto dstQ1 = srcQ1InDst.ClampMinMax(zero2f, dstSizef);
+
+    // Alright, time to go back to src!
+    // Normalized to the [0,1] abstact copy rect
+    const auto dstQ0Norm = (dstQ0 - dstP0f) / dstRectDiff;
+    const auto dstQ1Norm = (dstQ1 - dstP0f) / dstRectDiff;
+
+    // Map into src
+    const auto dstQ0InSrc = srcP0f + dstQ0Norm * srcRectDiff;
+    const auto dstQ1InSrc = srcP0f + dstQ1Norm * srcRectDiff;
+
+    const auto srcQ0Constrained = dstQ0InSrc.ClampMinMax(zero2f, srcSizef);
+    const auto srcQ1Constrained = dstQ1InSrc.ClampMinMax(zero2f, srcSizef);
+
+    // Round, don't floor:
+    srcP0 = (srcQ0Constrained + 0.5).StaticCast<ivec2>();
+    srcP1 = (srcQ1Constrained + 0.5).StaticCast<ivec2>();
+    dstP0 = (dstQ0 + 0.5).StaticCast<ivec2>();
+    dstP1 = (dstQ1 + 0.5).StaticCast<ivec2>();
+  }();
+
+  bool inBounds = true;
+  inBounds &= (srcP0 == srcP0.Clamp({0, 0}, AsVec(srcSize)));
+  inBounds &= (srcP1 == srcP1.Clamp({0, 0}, AsVec(srcSize)));
+  inBounds &= (dstP0 == dstP0.Clamp({0, 0}, AsVec(dstSize)));
+  inBounds &= (dstP1 == dstP1.Clamp({0, 0}, AsVec(dstSize)));
+  if (!inBounds) {
+    webgl->ErrorImplementationBug(
+        "Subrects still not within src and dst after constraining.");
+    return;
+  }
+
+  // -
+  // Execute as constrained
+
+  const auto& gl = webgl->gl;
+  const ScopedDrawCallWrapper wrapper(*webgl);
+
+  gl->fBlitFramebuffer(srcP0.x, srcP0.y, srcP1.x, srcP1.y, dstP0.x, dstP0.y,
+                       dstP1.x, dstP1.y, mask, filter);
+
+  // -
+
+  if (mask & LOCAL_GL_COLOR_BUFFER_BIT && !colorSrgbMatches && !gl->IsGLES() &&
+      gl->Version() < 440) {
+    // Mostly for Mac.
+    // Remember, we have to filter in the *linear* format blit.
+
+    // src -Blit-> fbB -DrawBlit-> fbC -Blit-> dst
+
+    const auto fbB = gl::MozFramebuffer::Create(gl, {1, 1}, 0, false);
+    const auto fbC = gl::MozFramebuffer::Create(gl, {1, 1}, 0, false);
+
+    // -
+
+    auto sizeBC = srcSize;
+    GLenum formatC = LOCAL_GL_RGBA8;
+    if (srcColorFormat->isSRGB) {
+      // srgb -> linear
+    } else {
+      // linear -> srgb
+      sizeBC = dstSize;
+      formatC = LOCAL_GL_SRGB8_ALPHA8;
+    }
+
+    const auto fnSetTex = [&](const gl::MozFramebuffer& fb,
+                              const GLenum format) {
+      const gl::ScopedBindTexture bindTex(gl, fb.ColorTex());
+      gl->fTexStorage2D(LOCAL_GL_TEXTURE_2D, 1, format, sizeBC.width,
+                        sizeBC.height);
+    };
+    fnSetTex(*fbB, srcColorFormat->sizedFormat);
+    fnSetTex(*fbC, formatC);
+
+    // -
+
+    {
+      const gl::ScopedBindFramebuffer bindFb(gl);
+      gl->fBindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER, fbB->mFB);
+
+      if (srcColorFormat->isSRGB) {
+        // srgb -> linear
+        gl->fBlitFramebuffer(srcP0.x, srcP0.y, srcP1.x, srcP1.y, srcP0.x,
+                             srcP0.y, srcP1.x, srcP1.y,
+                             LOCAL_GL_COLOR_BUFFER_BIT, LOCAL_GL_NEAREST);
+      } else {
+        // linear -> srgb
+        gl->fBlitFramebuffer(srcP0.x, srcP0.y, srcP1.x, srcP1.y, dstP0.x,
+                             dstP0.y, dstP1.x, dstP1.y,
+                             LOCAL_GL_COLOR_BUFFER_BIT, filter);
+      }
+
+      gl->fBindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER, fbC->mFB);
+      gl->BlitHelper()->DrawBlitTextureToFramebuffer(fbB->ColorTex(), sizeBC,
+                                                     sizeBC);
+    }
+
+    {
+      const gl::ScopedBindFramebuffer bindFb(gl);
+      gl->fBindFramebuffer(LOCAL_GL_READ_FRAMEBUFFER, fbC->mFB);
+
+      if (srcColorFormat->isSRGB) {
+        // srgb -> linear
+        gl->fBlitFramebuffer(srcP0.x, srcP0.y, srcP1.x, srcP1.y, dstP0.x,
+                             dstP0.y, dstP1.x, dstP1.y,
+                             LOCAL_GL_COLOR_BUFFER_BIT, filter);
+      } else {
+        // linear -> srgb
+        gl->fBlitFramebuffer(dstP0.x, dstP0.y, dstP1.x, dstP1.y, dstP0.x,
+                             dstP0.y, dstP1.x, dstP1.y,
+                             LOCAL_GL_COLOR_BUFFER_BIT, LOCAL_GL_NEAREST);
+      }
+    }
+  }
+
+  // -
+  // glBlitFramebuffer ignores glColorMask!
+
+  if (!webgl->mBoundDrawFramebuffer && webgl->mNeedsFakeNoAlpha) {
+    const auto dstRectMin = MinExtents(dstP0, dstP1);
+    const auto dstRectMax = MaxExtents(dstP0, dstP1);
+    const auto dstRectSize = dstRectMax - dstRectMin;
+    const WebGLContext::ScissorRect dstRect = {dstRectMin.x, dstRectMin.y,
+                                               dstRectSize.x, dstRectSize.y};
+    dstRect.Apply(*gl);
+
+    const auto forClear = webgl::ScopedPrepForResourceClear{*webgl};
+
+    gl->fClearColor(0, 0, 0, 1);
+    webgl->DoColorMask(Some(0), 0b1000);  // Only alpha.
+    gl->fClear(LOCAL_GL_COLOR_BUFFER_BIT);
+
+    webgl->mScissorRect.Apply(*gl);
+  }
+}
+
+}  // namespace mozilla