Adding upstream version 124.0.1.upstream/124.0.1

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

1 files changed, 1902 insertions, 0 deletions

diff --git a/dom/canvas/WebGLTextureUpload.cpp b/dom/canvas/WebGLTextureUpload.cpp
new file mode 100644
index 0000000000..6686c34178
--- /dev/null
+++ b/dom/canvas/WebGLTextureUpload.cpp
@@ -0,0 +1,1902 @@
+/* -*- 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 "WebGLTextureUpload.h"
+#include "WebGLTexture.h"
+
+#include <algorithm>
+#include <limits>
+
+#include "CanvasUtils.h"
+#include "ClientWebGLContext.h"
+#include "GLBlitHelper.h"
+#include "GLContext.h"
+#include "mozilla/Casting.h"
+#include "mozilla/gfx/2D.h"
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/dom/HTMLCanvasElement.h"
+#include "mozilla/dom/HTMLVideoElement.h"
+#include "mozilla/dom/ImageBitmap.h"
+#include "mozilla/dom/ImageData.h"
+#include "mozilla/dom/OffscreenCanvas.h"
+#include "mozilla/MathAlgorithms.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/StaticPrefs_webgl.h"
+#include "mozilla/Unused.h"
+#include "nsLayoutUtils.h"
+#include "ScopedGLHelpers.h"
+#include "TexUnpackBlob.h"
+#include "WebGLBuffer.h"
+#include "WebGLContext.h"
+#include "WebGLContextUtils.h"
+#include "WebGLFramebuffer.h"
+#include "WebGLTexelConversions.h"
+
+namespace mozilla {
+namespace webgl {
+
+// The canvas spec says that drawImage should draw the first frame of
+// animated images. The webgl spec doesn't mention the issue, so we do the
+// same as drawImage.
+static constexpr uint32_t kDefaultSurfaceFromElementFlags =
+    nsLayoutUtils::SFE_WANT_FIRST_FRAME_IF_IMAGE |
+    nsLayoutUtils::SFE_USE_ELEMENT_SIZE_IF_VECTOR |
+    nsLayoutUtils::SFE_EXACT_SIZE_SURFACE |
+    nsLayoutUtils::SFE_ALLOW_NON_PREMULT;
+
+Maybe<TexUnpackBlobDesc> FromImageBitmap(const GLenum target, Maybe<uvec3> size,
+                                         const dom::ImageBitmap& imageBitmap,
+                                         ErrorResult* const out_rv) {
+  if (imageBitmap.IsWriteOnly()) {
+    out_rv->Throw(NS_ERROR_DOM_SECURITY_ERR);
+    return {};
+  }
+
+  const auto cloneData = imageBitmap.ToCloneData();
+  if (!cloneData) {
+    return {};
+  }
+
+  const RefPtr<gfx::DataSourceSurface> surf = cloneData->mSurface;
+  const auto imageSize = *uvec2::FromSize(surf->GetSize());
+  if (!size) {
+    size.emplace(imageSize.x, imageSize.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."
+  return Some(TexUnpackBlobDesc{target,
+                                size.value(),
+                                cloneData->mAlphaType,
+                                {},
+                                {},
+                                Some(imageSize),
+                                nullptr,
+                                {},
+                                surf,
+                                {},
+                                false});
+}
+
+static layers::SurfaceDescriptor Flatten(const layers::SurfaceDescriptor& sd) {
+  const auto sdType = sd.type();
+  if (sdType != layers::SurfaceDescriptor::TSurfaceDescriptorGPUVideo) {
+    return sd;
+  }
+  const auto& sdv = sd.get_SurfaceDescriptorGPUVideo();
+  const auto& sdvType = sdv.type();
+  if (sdvType !=
+      layers::SurfaceDescriptorGPUVideo::TSurfaceDescriptorRemoteDecoder) {
+    return sd;
+  }
+
+  const auto& sdrd = sdv.get_SurfaceDescriptorRemoteDecoder();
+  const auto& subdesc = sdrd.subdesc();
+  const auto& subdescType = subdesc.type();
+  switch (subdescType) {
+    case layers::RemoteDecoderVideoSubDescriptor::T__None:
+    case layers::RemoteDecoderVideoSubDescriptor::Tnull_t:
+      return sd;
+
+    case layers::RemoteDecoderVideoSubDescriptor::TSurfaceDescriptorD3D10:
+      return subdesc.get_SurfaceDescriptorD3D10();
+    case layers::RemoteDecoderVideoSubDescriptor::TSurfaceDescriptorDXGIYCbCr:
+      return subdesc.get_SurfaceDescriptorDXGIYCbCr();
+    case layers::RemoteDecoderVideoSubDescriptor::TSurfaceDescriptorDMABuf:
+      return subdesc.get_SurfaceDescriptorDMABuf();
+    case layers::RemoteDecoderVideoSubDescriptor::
+        TSurfaceDescriptorMacIOSurface:
+      return subdesc.get_SurfaceDescriptorMacIOSurface();
+    case layers::RemoteDecoderVideoSubDescriptor::
+        TSurfaceDescriptorDcompSurface:
+      return subdesc.get_SurfaceDescriptorDcompSurface();
+  }
+  MOZ_CRASH("unreachable");
+}
+
+Maybe<webgl::TexUnpackBlobDesc> FromOffscreenCanvas(
+    const ClientWebGLContext& webgl, const GLenum target, Maybe<uvec3> size,
+    const dom::OffscreenCanvas& canvas, ErrorResult* const out_error) {
+  if (canvas.IsWriteOnly()) {
+    webgl.EnqueueWarning(
+        "OffscreenCanvas is write-only, thus cannot be uploaded.");
+    out_error->ThrowSecurityError(
+        "OffscreenCanvas is write-only, thus cannot be uploaded.");
+    return {};
+  }
+
+  auto sfer = nsLayoutUtils::SurfaceFromOffscreenCanvas(
+      const_cast<dom::OffscreenCanvas*>(&canvas),
+      kDefaultSurfaceFromElementFlags);
+  return FromSurfaceFromElementResult(webgl, target, size, sfer, out_error);
+}
+
+Maybe<webgl::TexUnpackBlobDesc> FromVideoFrame(
+    const ClientWebGLContext& webgl, const GLenum target, Maybe<uvec3> size,
+    const dom::VideoFrame& videoFrame, ErrorResult* const out_error) {
+  auto sfer = nsLayoutUtils::SurfaceFromVideoFrame(
+      const_cast<dom::VideoFrame*>(&videoFrame),
+      kDefaultSurfaceFromElementFlags);
+  return FromSurfaceFromElementResult(webgl, target, size, sfer, out_error);
+}
+
+Maybe<webgl::TexUnpackBlobDesc> FromDomElem(const ClientWebGLContext& webgl,
+                                            const GLenum target,
+                                            Maybe<uvec3> size,
+                                            const dom::Element& elem,
+                                            ErrorResult* const out_error) {
+  if (elem.IsHTMLElement(nsGkAtoms::canvas)) {
+    const dom::HTMLCanvasElement* srcCanvas =
+        static_cast<const dom::HTMLCanvasElement*>(&elem);
+    if (srcCanvas->IsWriteOnly()) {
+      out_error->Throw(NS_ERROR_DOM_SECURITY_ERR);
+      return {};
+    }
+  }
+
+  uint32_t flags = kDefaultSurfaceFromElementFlags;
+  const auto& unpacking = webgl.State().mPixelUnpackState;
+  if (unpacking.colorspaceConversion == LOCAL_GL_NONE) {
+    flags |= nsLayoutUtils::SFE_NO_COLORSPACE_CONVERSION;
+  }
+
+  RefPtr<gfx::DrawTarget> idealDrawTarget = nullptr;  // Don't care for now.
+  auto sfer = nsLayoutUtils::SurfaceFromElement(
+      const_cast<dom::Element*>(&elem), flags, idealDrawTarget);
+  return FromSurfaceFromElementResult(webgl, target, size, sfer, out_error);
+}
+
+Maybe<webgl::TexUnpackBlobDesc> FromSurfaceFromElementResult(
+    const ClientWebGLContext& webgl, const GLenum target, Maybe<uvec3> size,
+    SurfaceFromElementResult& sfer, ErrorResult* const out_error) {
+  uvec2 elemSize;
+
+  const auto& layersImage = sfer.mLayersImage;
+  Maybe<layers::SurfaceDescriptor> sd;
+  if (layersImage) {
+    elemSize = *uvec2::FromSize(layersImage->GetSize());
+
+    sd = layersImage->GetDesc();
+    if (sd) {
+      sd = Some(Flatten(*sd));
+    }
+    if (!sd) {
+      NS_WARNING("No SurfaceDescriptor for layers::Image!");
+    }
+  }
+
+  RefPtr<gfx::DataSourceSurface> dataSurf;
+  if (!sd && sfer.GetSourceSurface()) {
+    const auto surf = sfer.GetSourceSurface();
+    elemSize = *uvec2::FromSize(surf->GetSize());
+
+    // WARNING: OSX can lose our MakeCurrent here.
+    dataSurf = surf->GetDataSurface();
+  }
+
+  //////
+
+  if (!size) {
+    size.emplace(elemSize.x, elemSize.y, 1);
+  }
+
+  ////
+
+  if (!sd && !dataSurf) {
+    webgl.EnqueueWarning("Resource has no data (yet?). Uploading zeros.");
+    if (!size) {
+      size.emplace(0, 0, 1);
+    }
+    return Some(
+        TexUnpackBlobDesc{target, size.value(), gfxAlphaType::NonPremult});
+  }
+
+  //////
+
+  // While it's counter-intuitive, the shape of the SFEResult API means that we
+  // should try to pull out a surface first, and then, if we do pull out a
+  // surface, check CORS/write-only/etc..
+
+  if (!sfer.mCORSUsed) {
+    auto& srcPrincipal = sfer.mPrincipal;
+    nsIPrincipal* dstPrincipal = webgl.PrincipalOrNull();
+    if (!dstPrincipal || !dstPrincipal->Subsumes(srcPrincipal)) {
+      webgl.EnqueueWarning("Cross-origin elements require CORS.");
+      out_error->Throw(NS_ERROR_DOM_SECURITY_ERR);
+      return {};
+    }
+  }
+
+  if (sfer.mIsWriteOnly) {
+    // mIsWriteOnly defaults to true, and so will be true even if SFE merely
+    // failed. Thus we must test mIsWriteOnly after successfully retrieving an
+    // Image or SourceSurface.
+    webgl.EnqueueWarning("Element is write-only, thus cannot be uploaded.");
+    out_error->Throw(NS_ERROR_DOM_SECURITY_ERR);
+    return {};
+  }
+
+  //////
+  // Ok, we're good!
+
+  return Some(TexUnpackBlobDesc{target,
+                                size.value(),
+                                sfer.mAlphaType,
+                                {},
+                                {},
+                                Some(elemSize),
+                                layersImage,
+                                sd,
+                                dataSurf});
+}
+
+}  // namespace webgl
+
+//////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////
+
+static bool ValidateTexImage(WebGLContext* webgl, WebGLTexture* texture,
+                             TexImageTarget target, uint32_t level,
+                             webgl::ImageInfo** const out_imageInfo) {
+  // Check level
+  if (level >= WebGLTexture::kMaxLevelCount) {
+    webgl->ErrorInvalidValue("`level` is too large.");
+    return false;
+  }
+
+  auto& imageInfo = texture->ImageInfoAt(target, level);
+  *out_imageInfo = &imageInfo;
+  return true;
+}
+
+// For *TexImage*
+bool WebGLTexture::ValidateTexImageSpecification(
+    TexImageTarget target, uint32_t level, const uvec3& size,
+    webgl::ImageInfo** const out_imageInfo) {
+  if (mImmutable) {
+    mContext->ErrorInvalidOperation("Specified texture is immutable.");
+    return false;
+  }
+
+  // Do this early to validate `level`.
+  webgl::ImageInfo* imageInfo;
+  if (!ValidateTexImage(mContext, this, target, level, &imageInfo))
+    return false;
+
+  if (mTarget == LOCAL_GL_TEXTURE_CUBE_MAP && size.x != size.y) {
+    mContext->ErrorInvalidValue("Cube map images must be square.");
+    return false;
+  }
+
+  /* GLES 3.0.4, p133-134:
+   * GL_MAX_TEXTURE_SIZE is *not* the max allowed texture size. Rather, it is
+   * the max (width/height) size guaranteed not to generate an INVALID_VALUE for
+   * too-large dimensions. Sizes larger than GL_MAX_TEXTURE_SIZE *may or may
+   * not* result in an INVALID_VALUE, or possibly GL_OOM.
+   *
+   * However, we have needed to set our maximums lower in the past to prevent
+   * resource corruption. Therefore we have limits.maxTex2dSize, which is
+   * neither necessarily lower nor higher than MAX_TEXTURE_SIZE.
+   *
+   * Note that limits.maxTex2dSize must be >= than the advertized
+   * MAX_TEXTURE_SIZE. For simplicity, we advertize MAX_TEXTURE_SIZE as
+   * limits.maxTex2dSize.
+   */
+
+  uint32_t maxWidthHeight = 0;
+  uint32_t maxDepth = 0;
+  uint32_t maxLevel = 0;
+
+  const auto& limits = mContext->Limits();
+  MOZ_ASSERT(level <= 31);
+  switch (target.get()) {
+    case LOCAL_GL_TEXTURE_2D:
+      maxWidthHeight = limits.maxTex2dSize >> level;
+      maxDepth = 1;
+      maxLevel = CeilingLog2(limits.maxTex2dSize);
+      break;
+
+    case LOCAL_GL_TEXTURE_3D:
+      maxWidthHeight = limits.maxTex3dSize >> level;
+      maxDepth = maxWidthHeight;
+      maxLevel = CeilingLog2(limits.maxTex3dSize);
+      break;
+
+    case LOCAL_GL_TEXTURE_2D_ARRAY:
+      maxWidthHeight = limits.maxTex2dSize >> level;
+      // "The maximum number of layers for two-dimensional array textures
+      // (depth) must be at least MAX_ARRAY_TEXTURE_LAYERS for all levels."
+      maxDepth = limits.maxTexArrayLayers;
+      maxLevel = CeilingLog2(limits.maxTex2dSize);
+      break;
+
+    default:  // cube maps
+      MOZ_ASSERT(IsCubeMap());
+      maxWidthHeight = limits.maxTexCubeSize >> level;
+      maxDepth = 1;
+      maxLevel = CeilingLog2(limits.maxTexCubeSize);
+      break;
+  }
+
+  if (level > maxLevel) {
+    mContext->ErrorInvalidValue("Requested level is not supported for target.");
+    return false;
+  }
+
+  if (size.x > maxWidthHeight || size.y > maxWidthHeight || size.z > maxDepth) {
+    mContext->ErrorInvalidValue("Requested size at this level is unsupported.");
+    return false;
+  }
+
+  {
+    /* GL ES Version 2.0.25 - 3.7.1 Texture Image Specification
+     *   "If level is greater than zero, and either width or
+     *   height is not a power-of-two, the error INVALID_VALUE is
+     *   generated."
+     *
+     * This restriction does not apply to GL ES Version 3.0+.
+     */
+    bool requirePOT = (!mContext->IsWebGL2() && level != 0);
+
+    if (requirePOT) {
+      if (!IsPowerOfTwo(size.x) || !IsPowerOfTwo(size.y)) {
+        mContext->ErrorInvalidValue(
+            "For level > 0, width and height must be"
+            " powers of two.");
+        return false;
+      }
+    }
+  }
+
+  *out_imageInfo = imageInfo;
+  return true;
+}
+
+// For *TexSubImage*
+bool WebGLTexture::ValidateTexImageSelection(
+    TexImageTarget target, uint32_t level, const uvec3& offset,
+    const uvec3& size, webgl::ImageInfo** const out_imageInfo) {
+  webgl::ImageInfo* imageInfo;
+  if (!ValidateTexImage(mContext, this, target, level, &imageInfo))
+    return false;
+
+  if (!imageInfo->IsDefined()) {
+    mContext->ErrorInvalidOperation(
+        "The specified TexImage has not yet been"
+        " specified.");
+    return false;
+  }
+
+  const auto totalX = CheckedUint32(offset.x) + size.x;
+  const auto totalY = CheckedUint32(offset.y) + size.y;
+  const auto totalZ = CheckedUint32(offset.z) + size.z;
+
+  if (!totalX.isValid() || totalX.value() > imageInfo->mWidth ||
+      !totalY.isValid() || totalY.value() > imageInfo->mHeight ||
+      !totalZ.isValid() || totalZ.value() > imageInfo->mDepth) {
+    mContext->ErrorInvalidValue(
+        "Offset+size must be <= the size of the existing"
+        " specified image.");
+    return false;
+  }
+
+  *out_imageInfo = imageInfo;
+  return true;
+}
+
+static bool ValidateCompressedTexUnpack(WebGLContext* webgl, const uvec3& size,
+                                        const webgl::FormatInfo* format,
+                                        size_t dataSize) {
+  auto compression = format->compression;
+
+  auto bytesPerBlock = compression->bytesPerBlock;
+  auto blockWidth = compression->blockWidth;
+  auto blockHeight = compression->blockHeight;
+
+  auto widthInBlocks = CheckedUint32(size.x) / blockWidth;
+  auto heightInBlocks = CheckedUint32(size.y) / blockHeight;
+  if (size.x % blockWidth) widthInBlocks += 1;
+  if (size.y % blockHeight) heightInBlocks += 1;
+
+  const CheckedUint32 blocksPerImage = widthInBlocks * heightInBlocks;
+  const CheckedUint32 bytesPerImage = bytesPerBlock * blocksPerImage;
+  const CheckedUint32 bytesNeeded = bytesPerImage * size.z;
+
+  if (!bytesNeeded.isValid()) {
+    webgl->ErrorOutOfMemory("Overflow while computing the needed buffer size.");
+    return false;
+  }
+
+  if (dataSize != bytesNeeded.value()) {
+    webgl->ErrorInvalidValue(
+        "Provided buffer's size must match expected size."
+        " (needs %u, has %zu)",
+        bytesNeeded.value(), dataSize);
+    return false;
+  }
+
+  return true;
+}
+
+static bool DoChannelsMatchForCopyTexImage(const webgl::FormatInfo* srcFormat,
+                                           const webgl::FormatInfo* dstFormat) {
+  // GLES 3.0.4 p140 Table 3.16 "Valid CopyTexImage source
+  // framebuffer/destination texture base internal format combinations."
+
+  switch (srcFormat->unsizedFormat) {
+    case webgl::UnsizedFormat::RGBA:
+      switch (dstFormat->unsizedFormat) {
+        case webgl::UnsizedFormat::A:
+        case webgl::UnsizedFormat::L:
+        case webgl::UnsizedFormat::LA:
+        case webgl::UnsizedFormat::R:
+        case webgl::UnsizedFormat::RG:
+        case webgl::UnsizedFormat::RGB:
+        case webgl::UnsizedFormat::RGBA:
+          return true;
+        default:
+          return false;
+      }
+
+    case webgl::UnsizedFormat::RGB:
+      switch (dstFormat->unsizedFormat) {
+        case webgl::UnsizedFormat::L:
+        case webgl::UnsizedFormat::R:
+        case webgl::UnsizedFormat::RG:
+        case webgl::UnsizedFormat::RGB:
+          return true;
+        default:
+          return false;
+      }
+
+    case webgl::UnsizedFormat::RG:
+      switch (dstFormat->unsizedFormat) {
+        case webgl::UnsizedFormat::L:
+        case webgl::UnsizedFormat::R:
+        case webgl::UnsizedFormat::RG:
+          return true;
+        default:
+          return false;
+      }
+
+    case webgl::UnsizedFormat::R:
+      switch (dstFormat->unsizedFormat) {
+        case webgl::UnsizedFormat::L:
+        case webgl::UnsizedFormat::R:
+          return true;
+        default:
+          return false;
+      }
+
+    default:
+      return false;
+  }
+}
+
+static bool EnsureImageDataInitializedForUpload(
+    WebGLTexture* tex, TexImageTarget target, uint32_t level,
+    const uvec3& offset, const uvec3& size, webgl::ImageInfo* imageInfo,
+    bool* const out_expectsInit = nullptr) {
+  if (out_expectsInit) {
+    *out_expectsInit = false;
+  }
+  if (!imageInfo->mUninitializedSlices) return true;
+
+  if (size.x == imageInfo->mWidth && size.y == imageInfo->mHeight) {
+    bool expectsInit = false;
+    auto& isSliceUninit = *imageInfo->mUninitializedSlices;
+    for (const auto z : IntegerRange(offset.z, offset.z + size.z)) {
+      if (!isSliceUninit[z]) continue;
+      expectsInit = true;
+      isSliceUninit[z] = false;
+    }
+    if (out_expectsInit) {
+      *out_expectsInit = expectsInit;
+    }
+
+    if (!expectsInit) return true;
+
+    bool hasUninitialized = false;
+    for (const auto z : IntegerRange(imageInfo->mDepth)) {
+      hasUninitialized |= isSliceUninit[z];
+    }
+    if (!hasUninitialized) {
+      imageInfo->mUninitializedSlices = Nothing();
+    }
+    return true;
+  }
+
+  WebGLContext* webgl = tex->mContext;
+  webgl->GenerateWarning(
+      "Texture has not been initialized prior to a"
+      " partial upload, forcing the browser to clear it."
+      " This may be slow.");
+  if (!tex->EnsureImageDataInitialized(target, level)) {
+    MOZ_ASSERT(false, "Unexpected failure to init image data.");
+    return false;
+  }
+
+  return true;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////
+// Actual calls
+
+static inline GLenum DoTexStorage(gl::GLContext* gl, TexTarget target,
+                                  GLsizei levels, GLenum sizedFormat,
+                                  GLsizei width, GLsizei height,
+                                  GLsizei depth) {
+  gl::GLContext::LocalErrorScope errorScope(*gl);
+
+  switch (target.get()) {
+    case LOCAL_GL_TEXTURE_2D:
+    case LOCAL_GL_TEXTURE_CUBE_MAP:
+      MOZ_ASSERT(depth == 1);
+      gl->fTexStorage2D(target.get(), levels, sizedFormat, width, height);
+      break;
+
+    case LOCAL_GL_TEXTURE_3D:
+    case LOCAL_GL_TEXTURE_2D_ARRAY:
+      gl->fTexStorage3D(target.get(), levels, sizedFormat, width, height,
+                        depth);
+      break;
+
+    default:
+      MOZ_CRASH("GFX: bad target");
+  }
+
+  return errorScope.GetError();
+}
+
+bool IsTarget3D(TexImageTarget target) {
+  switch (target.get()) {
+    case LOCAL_GL_TEXTURE_2D:
+    case LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_X:
+    case LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
+    case LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
+    case LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
+    case LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
+    case LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
+      return false;
+
+    case LOCAL_GL_TEXTURE_3D:
+    case LOCAL_GL_TEXTURE_2D_ARRAY:
+      return true;
+
+    default:
+      MOZ_CRASH("GFX: bad target");
+  }
+}
+
+GLenum DoTexImage(gl::GLContext* gl, TexImageTarget target, GLint level,
+                  const webgl::DriverUnpackInfo* dui, GLsizei width,
+                  GLsizei height, GLsizei depth, const void* data) {
+  const GLint border = 0;
+
+  gl::GLContext::LocalErrorScope errorScope(*gl);
+
+  if (IsTarget3D(target)) {
+    gl->fTexImage3D(target.get(), level, dui->internalFormat, width, height,
+                    depth, border, dui->unpackFormat, dui->unpackType, data);
+  } else {
+    MOZ_ASSERT(depth == 1);
+    gl->fTexImage2D(target.get(), level, dui->internalFormat, width, height,
+                    border, dui->unpackFormat, dui->unpackType, data);
+  }
+
+  return errorScope.GetError();
+}
+
+GLenum DoTexSubImage(gl::GLContext* gl, TexImageTarget target, GLint level,
+                     GLint xOffset, GLint yOffset, GLint zOffset, GLsizei width,
+                     GLsizei height, GLsizei depth,
+                     const webgl::PackingInfo& pi, const void* data) {
+  gl::GLContext::LocalErrorScope errorScope(*gl);
+
+  if (IsTarget3D(target)) {
+    gl->fTexSubImage3D(target.get(), level, xOffset, yOffset, zOffset, width,
+                       height, depth, pi.format, pi.type, data);
+  } else {
+    MOZ_ASSERT(zOffset == 0);
+    MOZ_ASSERT(depth == 1);
+    gl->fTexSubImage2D(target.get(), level, xOffset, yOffset, width, height,
+                       pi.format, pi.type, data);
+  }
+
+  return errorScope.GetError();
+}
+
+static inline GLenum DoCompressedTexImage(gl::GLContext* gl,
+                                          TexImageTarget target, GLint level,
+                                          GLenum internalFormat, GLsizei width,
+                                          GLsizei height, GLsizei depth,
+                                          GLsizei dataSize, const void* data) {
+  const GLint border = 0;
+
+  gl::GLContext::LocalErrorScope errorScope(*gl);
+
+  if (IsTarget3D(target)) {
+    gl->fCompressedTexImage3D(target.get(), level, internalFormat, width,
+                              height, depth, border, dataSize, data);
+  } else {
+    MOZ_ASSERT(depth == 1);
+    gl->fCompressedTexImage2D(target.get(), level, internalFormat, width,
+                              height, border, dataSize, data);
+  }
+
+  return errorScope.GetError();
+}
+
+GLenum DoCompressedTexSubImage(gl::GLContext* gl, TexImageTarget target,
+                               GLint level, GLint xOffset, GLint yOffset,
+                               GLint zOffset, GLsizei width, GLsizei height,
+                               GLsizei depth, GLenum sizedUnpackFormat,
+                               GLsizei dataSize, const void* data) {
+  gl::GLContext::LocalErrorScope errorScope(*gl);
+
+  if (IsTarget3D(target)) {
+    gl->fCompressedTexSubImage3D(target.get(), level, xOffset, yOffset, zOffset,
+                                 width, height, depth, sizedUnpackFormat,
+                                 dataSize, data);
+  } else {
+    MOZ_ASSERT(zOffset == 0);
+    MOZ_ASSERT(depth == 1);
+    gl->fCompressedTexSubImage2D(target.get(), level, xOffset, yOffset, width,
+                                 height, sizedUnpackFormat, dataSize, data);
+  }
+
+  return errorScope.GetError();
+}
+
+static inline GLenum DoCopyTexSubImage(gl::GLContext* gl, TexImageTarget target,
+                                       GLint level, GLint xOffset,
+                                       GLint yOffset, GLint zOffset, GLint x,
+                                       GLint y, GLsizei width, GLsizei height) {
+  gl::GLContext::LocalErrorScope errorScope(*gl);
+
+  if (IsTarget3D(target)) {
+    gl->fCopyTexSubImage3D(target.get(), level, xOffset, yOffset, zOffset, x, y,
+                           width, height);
+  } else {
+    MOZ_ASSERT(zOffset == 0);
+    gl->fCopyTexSubImage2D(target.get(), level, xOffset, yOffset, x, y, width,
+                           height);
+  }
+
+  return errorScope.GetError();
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////
+// Actual (mostly generic) function implementations
+
+static bool ValidateCompressedTexImageRestrictions(
+    const WebGLContext* webgl, TexImageTarget target, uint32_t level,
+    const webgl::FormatInfo* format, const uvec3& size) {
+  const auto fnIsDimValid_S3TC = [&](const char* const name, uint32_t levelSize,
+                                     uint32_t blockSize) {
+    const auto impliedBaseSize = levelSize << level;
+    if (impliedBaseSize % blockSize == 0) return true;
+    webgl->ErrorInvalidOperation(
+        "%u is never a valid %s for level %u, because it implies a base mip %s "
+        "of %u."
+        " %s requires that base mip levels have a %s multiple of %u.",
+        levelSize, name, level, name, impliedBaseSize, format->name, name,
+        blockSize);
+    return false;
+  };
+
+  switch (format->compression->family) {
+    case webgl::CompressionFamily::ASTC:
+      if (target == LOCAL_GL_TEXTURE_3D &&
+          !webgl->gl->IsExtensionSupported(
+              gl::GLContext::KHR_texture_compression_astc_hdr)) {
+        webgl->ErrorInvalidOperation("TEXTURE_3D requires ASTC's hdr profile.");
+        return false;
+      }
+      break;
+
+    case webgl::CompressionFamily::PVRTC:
+      if (!IsPowerOfTwo(size.x) || !IsPowerOfTwo(size.y)) {
+        webgl->ErrorInvalidValue("%s requires power-of-two width and height.",
+                                 format->name);
+        return false;
+      }
+      break;
+
+    case webgl::CompressionFamily::BPTC:
+    case webgl::CompressionFamily::RGTC:
+    case webgl::CompressionFamily::S3TC:
+      if (!fnIsDimValid_S3TC("width", size.x,
+                             format->compression->blockWidth) ||
+          !fnIsDimValid_S3TC("height", size.y,
+                             format->compression->blockHeight)) {
+        return false;
+      }
+      break;
+
+    // Default: There are no restrictions on CompressedTexImage.
+    case webgl::CompressionFamily::ES3:
+    case webgl::CompressionFamily::ETC1:
+      break;
+  }
+
+  return true;
+}
+
+static bool ValidateFormatAndSize(const WebGLContext* webgl,
+                                  TexImageTarget target,
+                                  const webgl::FormatInfo* format,
+                                  const uvec3& size) {
+  // Check if texture size will likely be rejected by the driver and give a more
+  // meaningful error message.
+  auto baseImageSize = CheckedInt<uint64_t>(format->estimatedBytesPerPixel) *
+                       (uint32_t)size.x * (uint32_t)size.y * (uint32_t)size.z;
+  if (target == LOCAL_GL_TEXTURE_CUBE_MAP) {
+    baseImageSize *= 6;
+  }
+  if (!baseImageSize.isValid() ||
+      baseImageSize.value() >
+          (uint64_t)StaticPrefs::webgl_max_size_per_texture_mib() *
+              (1024 * 1024)) {
+    webgl->ErrorOutOfMemory(
+        "Texture size too large; base image mebibytes > "
+        "webgl.max-size-per-texture-mib");
+    return false;
+  }
+
+  // GLES 3.0.4 p127:
+  // "Textures with a base internal format of DEPTH_COMPONENT or DEPTH_STENCIL
+  // are supported by texture image specification commands only if `target` is
+  // TEXTURE_2D, TEXTURE_2D_ARRAY, or TEXTURE_CUBE_MAP. Using these formats in
+  // conjunction with any other `target` will result in an INVALID_OPERATION
+  // error."
+  const bool ok = [&]() {
+    if (bool(format->d) & (target == LOCAL_GL_TEXTURE_3D)) return false;
+
+    if (format->compression) {
+      switch (format->compression->family) {
+        case webgl::CompressionFamily::ES3:
+        case webgl::CompressionFamily::S3TC:
+          if (target == LOCAL_GL_TEXTURE_3D) return false;
+          break;
+
+        case webgl::CompressionFamily::ETC1:
+        case webgl::CompressionFamily::PVRTC:
+        case webgl::CompressionFamily::RGTC:
+          if (target == LOCAL_GL_TEXTURE_3D ||
+              target == LOCAL_GL_TEXTURE_2D_ARRAY) {
+            return false;
+          }
+          break;
+        default:
+          break;
+      }
+    }
+    return true;
+  }();
+  if (!ok) {
+    webgl->ErrorInvalidOperation("Format %s cannot be used with target %s.",
+                                 format->name, GetEnumName(target.get()));
+    return false;
+  }
+
+  return true;
+}
+
+void WebGLTexture::TexStorage(TexTarget target, uint32_t levels,
+                              GLenum sizedFormat, const uvec3& size) {
+  // Check levels
+  if (levels < 1) {
+    mContext->ErrorInvalidValue("`levels` must be >= 1.");
+    return;
+  }
+
+  if (!size.x || !size.y || !size.z) {
+    mContext->ErrorInvalidValue("Dimensions must be non-zero.");
+    return;
+  }
+
+  const TexImageTarget testTarget =
+      IsCubeMap() ? LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_X : target.get();
+  webgl::ImageInfo* baseImageInfo;
+  if (!ValidateTexImageSpecification(testTarget, 0, size, &baseImageInfo)) {
+    return;
+  }
+  MOZ_ALWAYS_TRUE(baseImageInfo);
+
+  auto dstUsage = mContext->mFormatUsage->GetSizedTexUsage(sizedFormat);
+  if (!dstUsage) {
+    mContext->ErrorInvalidEnumInfo("internalformat", sizedFormat);
+    return;
+  }
+  auto dstFormat = dstUsage->format;
+
+  if (!ValidateFormatAndSize(mContext, testTarget, dstFormat, size)) return;
+
+  if (dstFormat->compression) {
+    if (!ValidateCompressedTexImageRestrictions(mContext, testTarget, 0,
+                                                dstFormat, size)) {
+      return;
+    }
+  }
+
+  ////////////////////////////////////
+
+  const bool levelsOk = [&]() {
+    // Right-shift is only defined for bits-1, which is too large anyways.
+    const auto lastLevel = uint32_t(levels - 1);
+    if (lastLevel > 31) return false;
+
+    const auto lastLevelWidth = uint32_t(size.x) >> lastLevel;
+    const auto lastLevelHeight = uint32_t(size.y) >> lastLevel;
+
+    // If these are all zero, then some earlier level was the final 1x1(x1)
+    // level.
+    bool ok = lastLevelWidth || lastLevelHeight;
+    if (target == LOCAL_GL_TEXTURE_3D) {
+      const auto lastLevelDepth = uint32_t(size.z) >> lastLevel;
+      ok |= bool(lastLevelDepth);
+    }
+    return ok;
+  }();
+  if (!levelsOk) {
+    mContext->ErrorInvalidOperation(
+        "Too many levels requested for the given"
+        " dimensions. (levels: %u, width: %u, height: %u,"
+        " depth: %u)",
+        levels, size.x, size.y, size.z);
+    return;
+  }
+
+  ////////////////////////////////////
+  // Do the thing!
+
+  GLenum error = DoTexStorage(mContext->gl, target.get(), levels, sizedFormat,
+                              size.x, size.y, size.z);
+
+  mContext->OnDataAllocCall();
+
+  if (error == LOCAL_GL_OUT_OF_MEMORY) {
+    mContext->ErrorOutOfMemory("Ran out of memory during texture allocation.");
+    Truncate();
+    return;
+  }
+  if (error) {
+    mContext->GenerateError(error, "Unexpected error from driver.");
+    const nsPrintfCString call(
+        "DoTexStorage(0x%04x, %i, 0x%04x, %i,%i,%i) -> 0x%04x", target.get(),
+        levels, sizedFormat, size.x, size.y, size.z, error);
+    gfxCriticalError() << "Unexpected error from driver: "
+                       << call.BeginReading();
+    return;
+  }
+
+  ////////////////////////////////////
+  // Update our specification data.
+
+  auto uninitializedSlices = Some(std::vector<bool>(size.z, true));
+  const webgl::ImageInfo newInfo{dstUsage, size.x, size.y, size.z,
+                                 std::move(uninitializedSlices)};
+
+  {
+    const auto base_level = mBaseMipmapLevel;
+    mBaseMipmapLevel = 0;
+
+    ImageInfoAtFace(0, 0) = newInfo;
+    PopulateMipChain(levels - 1);
+
+    mBaseMipmapLevel = base_level;
+  }
+
+  mImmutable = true;
+  mImmutableLevelCount = AutoAssertCast(levels);
+  ClampLevelBaseAndMax();
+}
+
+////////////////////////////////////////
+// Tex(Sub)Image
+
+// TexSubImage iff `!respectFormat`
+void WebGLTexture::TexImage(uint32_t level, GLenum respecFormat,
+                            const uvec3& offset, const webgl::PackingInfo& pi,
+                            const webgl::TexUnpackBlobDesc& src) {
+  Maybe<RawBuffer<>> cpuDataView;
+  if (src.cpuData) {
+    cpuDataView = Some(RawBuffer<>{src.cpuData->Data()});
+  }
+  const auto srcViewDesc = webgl::TexUnpackBlobDesc{src.imageTarget,
+                                                    src.size,
+                                                    src.srcAlphaType,
+                                                    std::move(cpuDataView),
+                                                    src.pboOffset,
+                                                    src.structuredSrcSize,
+                                                    src.image,
+                                                    src.sd,
+                                                    src.dataSurf,
+                                                    src.unpacking,
+                                                    src.applyUnpackTransforms};
+
+  const auto blob = webgl::TexUnpackBlob::Create(srcViewDesc);
+  if (!blob) {
+    MOZ_ASSERT(false);
+    return;
+  }
+
+  const auto imageTarget = blob->mDesc.imageTarget;
+  auto size = blob->mDesc.size;
+
+  if (!IsTarget3D(imageTarget)) {
+    size.z = 1;
+  }
+
+  ////////////////////////////////////
+  // Get dest info
+
+  const auto& fua = mContext->mFormatUsage;
+  const auto fnValidateUnpackEnums = [&]() {
+    if (!fua->AreUnpackEnumsValid(pi.format, pi.type)) {
+      mContext->ErrorInvalidEnum("Invalid unpack format/type: %s/%s",
+                                 EnumString(pi.format).c_str(),
+                                 EnumString(pi.type).c_str());
+      return false;
+    }
+    return true;
+  };
+
+  webgl::ImageInfo* imageInfo;
+  const webgl::FormatUsageInfo* dstUsage;
+  if (respecFormat) {
+    if (!ValidateTexImageSpecification(imageTarget, level, size, &imageInfo))
+      return;
+    MOZ_ASSERT(imageInfo);
+
+    if (!fua->IsInternalFormatEnumValid(respecFormat)) {
+      mContext->ErrorInvalidValue("Invalid internalformat: 0x%04x",
+                                  respecFormat);
+      return;
+    }
+
+    dstUsage = fua->GetSizedTexUsage(respecFormat);
+    if (!dstUsage) {
+      if (respecFormat != pi.format) {
+        /* GL ES Version 3.0.4 - 3.8.3 Texture Image Specification
+         *   "Specifying a combination of values for format, type, and
+         *   internalformat that is not listed as a valid combination
+         *   in tables 3.2 or 3.3 generates the error INVALID_OPERATION."
+         */
+        if (!fnValidateUnpackEnums()) return;
+        mContext->ErrorInvalidOperation(
+            "Unsized internalFormat must match"
+            " unpack format.");
+        return;
+      }
+
+      dstUsage = fua->GetUnsizedTexUsage(pi);
+    }
+
+    if (!dstUsage) {
+      if (!fnValidateUnpackEnums()) return;
+      mContext->ErrorInvalidOperation(
+          "Invalid internalformat/format/type:"
+          " 0x%04x/0x%04x/0x%04x",
+          respecFormat, pi.format, pi.type);
+      return;
+    }
+
+    const auto& dstFormat = dstUsage->format;
+    if (!ValidateFormatAndSize(mContext, imageTarget, dstFormat, size)) return;
+
+    if (!mContext->IsWebGL2() && dstFormat->d) {
+      if (imageTarget != LOCAL_GL_TEXTURE_2D || blob->HasData() || level != 0) {
+        mContext->ErrorInvalidOperation(
+            "With format %s, this function may only"
+            " be called with target=TEXTURE_2D,"
+            " data=null, and level=0.",
+            dstFormat->name);
+        return;
+      }
+    }
+  } else {
+    if (!ValidateTexImageSelection(imageTarget, level, offset, size,
+                                   &imageInfo)) {
+      return;
+    }
+    MOZ_ASSERT(imageInfo);
+    dstUsage = imageInfo->mFormat;
+
+    const auto& dstFormat = dstUsage->format;
+    if (!mContext->IsWebGL2() && dstFormat->d) {
+      mContext->ErrorInvalidOperation(
+          "Function may not be called on a texture of"
+          " format %s.",
+          dstFormat->name);
+      return;
+    }
+  }
+
+  ////////////////////////////////////
+  // Get source info
+
+  const webgl::DriverUnpackInfo* driverUnpackInfo;
+  if (!dstUsage->IsUnpackValid(pi, &driverUnpackInfo)) {
+    if (!fnValidateUnpackEnums()) return;
+    mContext->ErrorInvalidOperation(
+        "Mismatched internalFormat and format/type:"
+        " 0x%04x and 0x%04x/0x%04x",
+        respecFormat, pi.format, pi.type);
+    return;
+  }
+
+  if (!blob->Validate(mContext, pi)) return;
+
+  ////////////////////////////////////
+  // Do the thing!
+
+  Maybe<webgl::ImageInfo> newImageInfo;
+  bool isRespec = false;
+  if (respecFormat) {
+    // It's tempting to do allocation first, and TexSubImage second, but this is
+    // generally slower.
+    newImageInfo = Some(webgl::ImageInfo{dstUsage, size.x, size.y, size.z});
+    if (!blob->HasData()) {
+      newImageInfo->mUninitializedSlices =
+          Some(std::vector<bool>(size.z, true));
+    }
+
+    isRespec = (imageInfo->mWidth != newImageInfo->mWidth ||
+                imageInfo->mHeight != newImageInfo->mHeight ||
+                imageInfo->mDepth != newImageInfo->mDepth ||
+                imageInfo->mFormat != newImageInfo->mFormat);
+  } else {
+    if (!blob->HasData()) {
+      mContext->ErrorInvalidValue("`source` cannot be null.");
+      return;
+    }
+    if (!EnsureImageDataInitializedForUpload(this, imageTarget, level, offset,
+                                             size, imageInfo)) {
+      return;
+    }
+  }
+
+  webgl::PixelPackingState{}.AssertCurrentUnpack(*mContext->gl,
+                                                 mContext->IsWebGL2());
+
+  blob->mDesc.unpacking.ApplyUnpack(*mContext->gl, mContext->IsWebGL2(), size);
+  const auto revertUnpacking = MakeScopeExit([&]() {
+    webgl::PixelPackingState{}.ApplyUnpack(*mContext->gl, mContext->IsWebGL2(),
+                                           size);
+  });
+
+  const bool isSubImage = !respecFormat;
+  GLenum glError = 0;
+  if (!blob->TexOrSubImage(isSubImage, isRespec, this, level, driverUnpackInfo,
+                           offset.x, offset.y, offset.z, pi, &glError)) {
+    return;
+  }
+
+  if (glError == LOCAL_GL_OUT_OF_MEMORY) {
+    mContext->ErrorOutOfMemory("Driver ran out of memory during upload.");
+    Truncate();
+    return;
+  }
+
+  if (glError) {
+    const auto enumStr = EnumString(glError);
+    const nsPrintfCString dui(
+        "Unexpected error %s during upload. (dui: %x/%x/%x)", enumStr.c_str(),
+        driverUnpackInfo->internalFormat, driverUnpackInfo->unpackFormat,
+        driverUnpackInfo->unpackType);
+    mContext->ErrorInvalidOperation("%s", dui.BeginReading());
+    gfxCriticalError() << mContext->FuncName() << ": " << dui.BeginReading();
+    return;
+  }
+
+  ////////////////////////////////////
+  // Update our specification data?
+
+  if (respecFormat) {
+    mContext->OnDataAllocCall();
+    *imageInfo = *newImageInfo;
+    InvalidateCaches();
+  }
+}
+
+////////////////////////////////////////
+// CompressedTex(Sub)Image
+
+static inline bool IsSubImageBlockAligned(
+    const webgl::CompressedFormatInfo* compression,
+    const webgl::ImageInfo* imageInfo, GLint xOffset, GLint yOffset,
+    uint32_t width, uint32_t height) {
+  if (xOffset % compression->blockWidth != 0 ||
+      yOffset % compression->blockHeight != 0) {
+    return false;
+  }
+
+  if (width % compression->blockWidth != 0 &&
+      xOffset + width != imageInfo->mWidth)
+    return false;
+
+  if (height % compression->blockHeight != 0 &&
+      yOffset + height != imageInfo->mHeight)
+    return false;
+
+  return true;
+}
+
+// CompressedTexSubImage iff `sub`
+void WebGLTexture::CompressedTexImage(bool sub, GLenum imageTarget,
+                                      uint32_t level, GLenum formatEnum,
+                                      const uvec3& offset, const uvec3& size,
+                                      const Range<const uint8_t>& src,
+                                      const uint32_t pboImageSize,
+                                      const Maybe<uint64_t>& pboOffset) {
+  auto imageSize = pboImageSize;
+  if (pboOffset) {
+    const auto& buffer =
+        mContext->ValidateBufferSelection(LOCAL_GL_PIXEL_UNPACK_BUFFER);
+    if (!buffer) return;
+    auto availBytes = buffer->ByteLength();
+    if (*pboOffset > availBytes) {
+      mContext->GenerateError(
+          LOCAL_GL_INVALID_OPERATION,
+          "`offset` (%llu) must be <= PIXEL_UNPACK_BUFFER size (%llu).",
+          *pboOffset, availBytes);
+      return;
+    }
+    availBytes -= *pboOffset;
+    if (availBytes < pboImageSize) {
+      mContext->GenerateError(
+          LOCAL_GL_INVALID_OPERATION,
+          "PIXEL_UNPACK_BUFFER size minus `offset` (%llu) too small for"
+          " `pboImageSize` (%u).",
+          availBytes, pboImageSize);
+      return;
+    }
+  } else {
+    if (mContext->mBoundPixelUnpackBuffer) {
+      mContext->GenerateError(LOCAL_GL_INVALID_OPERATION,
+                              "PIXEL_UNPACK_BUFFER is non-null.");
+      return;
+    }
+    imageSize = src.length();
+  }
+
+  // -
+
+  const auto usage = mContext->mFormatUsage->GetSizedTexUsage(formatEnum);
+  if (!usage || !usage->format->compression) {
+    mContext->ErrorInvalidEnumArg("format", formatEnum);
+    return;
+  }
+
+  webgl::ImageInfo* imageInfo;
+  if (!sub) {
+    if (!ValidateTexImageSpecification(imageTarget, level, size, &imageInfo)) {
+      return;
+    }
+    MOZ_ASSERT(imageInfo);
+
+    if (!ValidateFormatAndSize(mContext, imageTarget, usage->format, size))
+      return;
+    if (!ValidateCompressedTexImageRestrictions(mContext, imageTarget, level,
+                                                usage->format, size)) {
+      return;
+    }
+  } else {
+    if (!ValidateTexImageSelection(imageTarget, level, offset, size,
+                                   &imageInfo))
+      return;
+    MOZ_ASSERT(imageInfo);
+
+    const auto dstUsage = imageInfo->mFormat;
+    if (usage != dstUsage) {
+      mContext->ErrorInvalidOperation(
+          "`format` must match the format of the"
+          " existing texture image.");
+      return;
+    }
+
+    const auto& format = usage->format;
+    switch (format->compression->family) {
+      // Forbidden:
+      case webgl::CompressionFamily::ETC1:
+        mContext->ErrorInvalidOperation(
+            "Format does not allow sub-image"
+            " updates.");
+        return;
+
+      // Block-aligned:
+      case webgl::CompressionFamily::ES3:   // Yes, the ES3 formats don't match
+                                            // the ES3
+      case webgl::CompressionFamily::S3TC:  // default behavior.
+      case webgl::CompressionFamily::BPTC:
+      case webgl::CompressionFamily::RGTC:
+        if (!IsSubImageBlockAligned(format->compression, imageInfo, offset.x,
+                                    offset.y, size.x, size.y)) {
+          mContext->ErrorInvalidOperation(
+              "Format requires block-aligned sub-image"
+              " updates.");
+          return;
+        }
+        break;
+
+      // Full-only: (The ES3 default)
+      case webgl::CompressionFamily::ASTC:
+      case webgl::CompressionFamily::PVRTC:
+        if (offset.x || offset.y || size.x != imageInfo->mWidth ||
+            size.y != imageInfo->mHeight) {
+          mContext->ErrorInvalidOperation(
+              "Format does not allow partial sub-image"
+              " updates.");
+          return;
+        }
+        break;
+    }
+  }
+
+  switch (usage->format->compression->family) {
+    case webgl::CompressionFamily::BPTC:
+    case webgl::CompressionFamily::RGTC:
+      if (level == 0) {
+        if (size.x % 4 != 0 || size.y % 4 != 0) {
+          mContext->ErrorInvalidOperation(
+              "For level == 0, width and height must be multiples of 4.");
+          return;
+        }
+      }
+      break;
+
+    default:
+      break;
+  }
+
+  if (!ValidateCompressedTexUnpack(mContext, size, usage->format, imageSize))
+    return;
+
+  ////////////////////////////////////
+  // Do the thing!
+
+  if (sub) {
+    if (!EnsureImageDataInitializedForUpload(this, imageTarget, level, offset,
+                                             size, imageInfo)) {
+      return;
+    }
+  }
+
+  const ScopedLazyBind bindPBO(mContext->gl, LOCAL_GL_PIXEL_UNPACK_BUFFER,
+                               mContext->mBoundPixelUnpackBuffer);
+  GLenum error;
+  const void* ptr;
+  if (pboOffset) {
+    ptr = reinterpret_cast<const void*>(*pboOffset);
+  } else {
+    ptr = reinterpret_cast<const void*>(src.begin().get());
+  }
+
+  if (!sub) {
+    error = DoCompressedTexImage(mContext->gl, imageTarget, level, formatEnum,
+                                 size.x, size.y, size.z, imageSize, ptr);
+  } else {
+    error = DoCompressedTexSubImage(mContext->gl, imageTarget, level, offset.x,
+                                    offset.y, offset.z, size.x, size.y, size.z,
+                                    formatEnum, imageSize, ptr);
+  }
+  if (error == LOCAL_GL_OUT_OF_MEMORY) {
+    mContext->ErrorOutOfMemory("Ran out of memory during upload.");
+    Truncate();
+    return;
+  }
+  if (error) {
+    mContext->GenerateError(error, "Unexpected error from driver.");
+    nsCString call;
+    if (!sub) {
+      call = nsPrintfCString(
+          "DoCompressedTexImage(0x%04x, %u, 0x%04x, %u,%u,%u, %u, %p)",
+          imageTarget, level, formatEnum, size.x, size.y, size.z, imageSize,
+          ptr);
+    } else {
+      call = nsPrintfCString(
+          "DoCompressedTexSubImage(0x%04x, %u, %u,%u,%u, %u,%u,%u, 0x%04x, %u, "
+          "%p)",
+          imageTarget, level, offset.x, offset.y, offset.z, size.x, size.y,
+          size.z, formatEnum, imageSize, ptr);
+    }
+    gfxCriticalError() << "Unexpected error " << gfx::hexa(error)
+                       << " from driver: " << call.BeginReading();
+    return;
+  }
+
+  ////////////////////////////////////
+  // Update our specification data?
+
+  if (!sub) {
+    const auto uninitializedSlices = Nothing();
+    const webgl::ImageInfo newImageInfo{usage, size.x, size.y, size.z,
+                                        uninitializedSlices};
+    *imageInfo = newImageInfo;
+    InvalidateCaches();
+  }
+}
+
+////////////////////////////////////////
+// CopyTex(Sub)Image
+
+static bool ValidateCopyTexImageFormats(WebGLContext* webgl,
+                                        const webgl::FormatInfo* srcFormat,
+                                        const webgl::FormatInfo* dstFormat) {
+  MOZ_ASSERT(!srcFormat->compression);
+  if (dstFormat->compression) {
+    webgl->ErrorInvalidEnum(
+        "Specified destination must not have a compressed"
+        " format.");
+    return false;
+  }
+
+  if (dstFormat->effectiveFormat == webgl::EffectiveFormat::RGB9_E5) {
+    webgl->ErrorInvalidOperation(
+        "RGB9_E5 is an invalid destination for"
+        " CopyTex(Sub)Image. (GLES 3.0.4 p145)");
+    return false;
+  }
+
+  if (!DoChannelsMatchForCopyTexImage(srcFormat, dstFormat)) {
+    webgl->ErrorInvalidOperation(
+        "Destination channels must be compatible with"
+        " source channels. (GLES 3.0.4 p140 Table 3.16)");
+    return false;
+  }
+
+  return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+class ScopedCopyTexImageSource {
+  WebGLContext* const mWebGL;
+  GLuint mRB;
+  GLuint mFB;
+
+ public:
+  ScopedCopyTexImageSource(WebGLContext* webgl, uint32_t srcWidth,
+                           uint32_t srcHeight,
+                           const webgl::FormatInfo* srcFormat,
+                           const webgl::FormatUsageInfo* dstUsage);
+  ~ScopedCopyTexImageSource();
+};
+
+ScopedCopyTexImageSource::ScopedCopyTexImageSource(
+    WebGLContext* webgl, uint32_t srcWidth, uint32_t srcHeight,
+    const webgl::FormatInfo* srcFormat, const webgl::FormatUsageInfo* dstUsage)
+    : mWebGL(webgl), mRB(0), mFB(0) {
+  switch (dstUsage->format->unsizedFormat) {
+    case webgl::UnsizedFormat::L:
+    case webgl::UnsizedFormat::A:
+    case webgl::UnsizedFormat::LA:
+      webgl->GenerateWarning(
+          "Copying to a LUMINANCE, ALPHA, or LUMINANCE_ALPHA"
+          " is deprecated, and has severely reduced performance"
+          " on some platforms.");
+      break;
+
+    default:
+      MOZ_ASSERT(!dstUsage->textureSwizzleRGBA);
+      return;
+  }
+
+  if (!dstUsage->textureSwizzleRGBA) return;
+
+  gl::GLContext* gl = webgl->gl;
+
+  GLenum sizedFormat;
+
+  switch (srcFormat->componentType) {
+    case webgl::ComponentType::NormUInt:
+      sizedFormat = LOCAL_GL_RGBA8;
+      break;
+
+    case webgl::ComponentType::Float:
+      if (webgl->IsExtensionEnabled(
+              WebGLExtensionID::WEBGL_color_buffer_float)) {
+        sizedFormat = LOCAL_GL_RGBA32F;
+        webgl->WarnIfImplicit(WebGLExtensionID::WEBGL_color_buffer_float);
+        break;
+      }
+
+      if (webgl->IsExtensionEnabled(
+              WebGLExtensionID::EXT_color_buffer_half_float)) {
+        sizedFormat = LOCAL_GL_RGBA16F;
+        webgl->WarnIfImplicit(WebGLExtensionID::EXT_color_buffer_half_float);
+        break;
+      }
+      MOZ_CRASH("GFX: Should be able to request CopyTexImage from Float.");
+
+    default:
+      MOZ_CRASH("GFX: Should be able to request CopyTexImage from this type.");
+  }
+
+  gl::ScopedTexture scopedTex(gl);
+  gl::ScopedBindTexture scopedBindTex(gl, scopedTex.Texture(),
+                                      LOCAL_GL_TEXTURE_2D);
+
+  gl->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_MIN_FILTER,
+                     LOCAL_GL_NEAREST);
+  gl->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_MAG_FILTER,
+                     LOCAL_GL_NEAREST);
+
+  GLint blitSwizzle[4] = {LOCAL_GL_ZERO};
+  switch (dstUsage->format->unsizedFormat) {
+    case webgl::UnsizedFormat::L:
+      blitSwizzle[0] = LOCAL_GL_RED;
+      break;
+
+    case webgl::UnsizedFormat::A:
+      blitSwizzle[0] = LOCAL_GL_ALPHA;
+      break;
+
+    case webgl::UnsizedFormat::LA:
+      blitSwizzle[0] = LOCAL_GL_RED;
+      blitSwizzle[1] = LOCAL_GL_ALPHA;
+      break;
+
+    default:
+      MOZ_CRASH("GFX: Unhandled unsizedFormat.");
+  }
+
+  gl->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_SWIZZLE_R,
+                     blitSwizzle[0]);
+  gl->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_SWIZZLE_G,
+                     blitSwizzle[1]);
+  gl->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_SWIZZLE_B,
+                     blitSwizzle[2]);
+  gl->fTexParameteri(LOCAL_GL_TEXTURE_2D, LOCAL_GL_TEXTURE_SWIZZLE_A,
+                     blitSwizzle[3]);
+
+  gl->fCopyTexImage2D(LOCAL_GL_TEXTURE_2D, 0, sizedFormat, 0, 0, srcWidth,
+                      srcHeight, 0);
+
+  // Now create the swizzled FB we'll be exposing.
+
+  GLuint rgbaRB = 0;
+  GLuint rgbaFB = 0;
+  {
+    gl->fGenRenderbuffers(1, &rgbaRB);
+    gl::ScopedBindRenderbuffer scopedRB(gl, rgbaRB);
+    gl->fRenderbufferStorage(LOCAL_GL_RENDERBUFFER, sizedFormat, srcWidth,
+                             srcHeight);
+
+    gl->fGenFramebuffers(1, &rgbaFB);
+    gl->fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, rgbaFB);
+    gl->fFramebufferRenderbuffer(LOCAL_GL_FRAMEBUFFER,
+                                 LOCAL_GL_COLOR_ATTACHMENT0,
+                                 LOCAL_GL_RENDERBUFFER, rgbaRB);
+
+    const GLenum status = gl->fCheckFramebufferStatus(LOCAL_GL_FRAMEBUFFER);
+    if (status != LOCAL_GL_FRAMEBUFFER_COMPLETE) {
+      MOZ_CRASH("GFX: Temp framebuffer is not complete.");
+    }
+  }
+
+  // Draw-blit rgbaTex into rgbaFB.
+  const gfx::IntSize srcSize(srcWidth, srcHeight);
+  {
+    const gl::ScopedBindFramebuffer bindFB(gl, rgbaFB);
+    gl->BlitHelper()->DrawBlitTextureToFramebuffer(scopedTex.Texture(), srcSize,
+                                                   srcSize);
+  }
+
+  // Leave RB and FB alive, and FB bound.
+  mRB = rgbaRB;
+  mFB = rgbaFB;
+}
+
+template <typename T>
+static inline GLenum ToGLHandle(const T& obj) {
+  return (obj ? obj->mGLName : 0);
+}
+
+ScopedCopyTexImageSource::~ScopedCopyTexImageSource() {
+  if (!mFB) {
+    MOZ_ASSERT(!mRB);
+    return;
+  }
+  MOZ_ASSERT(mRB);
+
+  gl::GLContext* gl = mWebGL->gl;
+
+  // If we're swizzling, it's because we're on a GL core (3.2+) profile, which
+  // has split framebuffer support.
+  gl->fBindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER,
+                       ToGLHandle(mWebGL->mBoundDrawFramebuffer));
+  gl->fBindFramebuffer(LOCAL_GL_READ_FRAMEBUFFER,
+                       ToGLHandle(mWebGL->mBoundReadFramebuffer));
+
+  gl->fDeleteFramebuffers(1, &mFB);
+  gl->fDeleteRenderbuffers(1, &mRB);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+static bool GetUnsizedFormatForCopy(GLenum internalFormat,
+                                    webgl::UnsizedFormat* const out) {
+  switch (internalFormat) {
+    case LOCAL_GL_RED:
+      *out = webgl::UnsizedFormat::R;
+      break;
+    case LOCAL_GL_RG:
+      *out = webgl::UnsizedFormat::RG;
+      break;
+    case LOCAL_GL_RGB:
+      *out = webgl::UnsizedFormat::RGB;
+      break;
+    case LOCAL_GL_RGBA:
+      *out = webgl::UnsizedFormat::RGBA;
+      break;
+    case LOCAL_GL_LUMINANCE:
+      *out = webgl::UnsizedFormat::L;
+      break;
+    case LOCAL_GL_ALPHA:
+      *out = webgl::UnsizedFormat::A;
+      break;
+    case LOCAL_GL_LUMINANCE_ALPHA:
+      *out = webgl::UnsizedFormat::LA;
+      break;
+
+    default:
+      return false;
+  }
+
+  return true;
+}
+
+static const webgl::FormatUsageInfo* ValidateCopyDestUsage(
+    WebGLContext* webgl, const webgl::FormatInfo* srcFormat,
+    GLenum internalFormat) {
+  const auto& fua = webgl->mFormatUsage;
+
+  switch (internalFormat) {
+    case LOCAL_GL_R8_SNORM:
+    case LOCAL_GL_RG8_SNORM:
+    case LOCAL_GL_RGB8_SNORM:
+    case LOCAL_GL_RGBA8_SNORM:
+      webgl->ErrorInvalidEnum("SNORM formats are invalid for CopyTexImage.");
+      return nullptr;
+  }
+
+  auto dstUsage = fua->GetSizedTexUsage(internalFormat);
+  if (!dstUsage) {
+    // Ok, maybe it's unsized.
+    webgl::UnsizedFormat unsizedFormat;
+    if (!GetUnsizedFormatForCopy(internalFormat, &unsizedFormat)) {
+      webgl->ErrorInvalidEnumInfo("internalFormat", internalFormat);
+      return nullptr;
+    }
+
+    const auto dstFormat = srcFormat->GetCopyDecayFormat(unsizedFormat);
+    if (dstFormat) {
+      dstUsage = fua->GetUsage(dstFormat->effectiveFormat);
+    }
+    if (!dstUsage) {
+      webgl->ErrorInvalidOperation(
+          "0x%04x is not a valid unsized format for"
+          " source format %s.",
+          internalFormat, srcFormat->name);
+      return nullptr;
+    }
+
+    return dstUsage;
+  }
+  // Alright, it's sized.
+
+  const auto dstFormat = dstUsage->format;
+
+  if (dstFormat->componentType != srcFormat->componentType) {
+    webgl->ErrorInvalidOperation(
+        "For sized internalFormats, source and dest"
+        " component types must match. (source: %s, dest:"
+        " %s)",
+        srcFormat->name, dstFormat->name);
+    return nullptr;
+  }
+
+  bool componentSizesMatch = true;
+  if (dstFormat->r) {
+    componentSizesMatch &= (dstFormat->r == srcFormat->r);
+  }
+  if (dstFormat->g) {
+    componentSizesMatch &= (dstFormat->g == srcFormat->g);
+  }
+  if (dstFormat->b) {
+    componentSizesMatch &= (dstFormat->b == srcFormat->b);
+  }
+  if (dstFormat->a) {
+    componentSizesMatch &= (dstFormat->a == srcFormat->a);
+  }
+
+  if (!componentSizesMatch) {
+    webgl->ErrorInvalidOperation(
+        "For sized internalFormats, source and dest"
+        " component sizes must match exactly. (source: %s,"
+        " dest: %s)",
+        srcFormat->name, dstFormat->name);
+    return nullptr;
+  }
+
+  return dstUsage;
+}
+
+static bool ValidateCopyTexImageForFeedback(const WebGLContext& webgl,
+                                            const WebGLTexture& tex,
+                                            const uint32_t mipLevel,
+                                            const uint32_t zLayer) {
+  const auto& fb = webgl.BoundReadFb();
+  if (fb) {
+    MOZ_ASSERT(fb->ColorReadBuffer());
+    const auto& attach = *fb->ColorReadBuffer();
+    MOZ_ASSERT(attach.ZLayerCount() ==
+               1);  // Multiview invalid for copyTexImage.
+
+    if (attach.Texture() == &tex && attach.Layer() == zLayer &&
+        attach.MipLevel() == mipLevel) {
+      // Note that the TexImageTargets *don't* have to match for this to be
+      // undefined per GLES 3.0.4 p211, thus an INVALID_OP in WebGL.
+      webgl.ErrorInvalidOperation(
+          "Feedback loop detected, as this texture"
+          " is already attached to READ_FRAMEBUFFER's"
+          " READ_BUFFER-selected COLOR_ATTACHMENT%u.",
+          attach.mAttachmentPoint);
+      return false;
+    }
+  }
+  return true;
+}
+
+static bool DoCopyTexOrSubImage(WebGLContext* webgl, bool isSubImage,
+                                bool needsInit, WebGLTexture* const tex,
+                                const TexImageTarget target, GLint level,
+                                GLint xWithinSrc, GLint yWithinSrc,
+                                uint32_t srcTotalWidth, uint32_t srcTotalHeight,
+                                const webgl::FormatUsageInfo* srcUsage,
+                                GLint xOffset, GLint yOffset, GLint zOffset,
+                                uint32_t dstWidth, uint32_t dstHeight,
+                                const webgl::FormatUsageInfo* dstUsage) {
+  const auto& gl = webgl->gl;
+
+  ////
+
+  int32_t readX, readY;
+  int32_t writeX, writeY;
+  int32_t rwWidth, rwHeight;
+  if (!Intersect(srcTotalWidth, xWithinSrc, dstWidth, &readX, &writeX,
+                 &rwWidth) ||
+      !Intersect(srcTotalHeight, yWithinSrc, dstHeight, &readY, &writeY,
+                 &rwHeight)) {
+    webgl->ErrorOutOfMemory("Bad subrect selection.");
+    return false;
+  }
+
+  writeX += xOffset;
+  writeY += yOffset;
+
+  ////
+
+  GLenum error = 0;
+  nsCString errorText;
+  do {
+    const auto& idealUnpack = dstUsage->idealUnpack;
+    const auto& pi = idealUnpack->ToPacking();
+
+    UniqueBuffer zeros;
+    const bool fullOverwrite =
+        (uint32_t(rwWidth) == dstWidth && uint32_t(rwHeight) == dstHeight);
+    if (needsInit && !fullOverwrite) {
+      CheckedInt<size_t> byteCount = BytesPerPixel(pi);
+      byteCount *= dstWidth;
+      byteCount *= dstHeight;
+
+      if (byteCount.isValid()) {
+        zeros = UniqueBuffer::Take(calloc(1u, byteCount.value()));
+      }
+
+      if (!zeros.get()) {
+        webgl->ErrorOutOfMemory("Ran out of memory allocating zeros.");
+        return false;
+      }
+    }
+
+    if (!isSubImage || zeros) {
+      webgl::PixelPackingState{}.AssertCurrentUnpack(*gl, webgl->IsWebGL2());
+
+      gl->fPixelStorei(LOCAL_GL_UNPACK_ALIGNMENT, 1);
+      const auto revert = MakeScopeExit(
+          [&]() { gl->fPixelStorei(LOCAL_GL_UNPACK_ALIGNMENT, 4); });
+      if (!isSubImage) {
+        error = DoTexImage(gl, target, level, idealUnpack, dstWidth, dstHeight,
+                           1, nullptr);
+        if (error) {
+          errorText = nsPrintfCString(
+              "DoTexImage(0x%04x, %i, {0x%04x, 0x%04x, 0x%04x}, %u,%u,1) -> "
+              "0x%04x",
+              target.get(), level, idealUnpack->internalFormat,
+              idealUnpack->unpackFormat, idealUnpack->unpackType, dstWidth,
+              dstHeight, error);
+          break;
+        }
+      }
+      if (zeros) {
+        error = DoTexSubImage(gl, target, level, xOffset, yOffset, zOffset,
+                              dstWidth, dstHeight, 1, pi, zeros.get());
+        if (error) {
+          errorText = nsPrintfCString(
+              "DoTexSubImage(0x%04x, %i, %i,%i,%i, %u,%u,1, {0x%04x, 0x%04x}) "
+              "-> "
+              "0x%04x",
+              target.get(), level, xOffset, yOffset, zOffset, dstWidth,
+              dstHeight, idealUnpack->unpackFormat, idealUnpack->unpackType,
+              error);
+          break;
+        }
+      }
+    }
+
+    if (!rwWidth || !rwHeight) {
+      // There aren't any pixels to copy, so we're 'done'.
+      return true;
+    }
+
+    const auto& srcFormat = srcUsage->format;
+    ScopedCopyTexImageSource maybeSwizzle(webgl, srcTotalWidth, srcTotalHeight,
+                                          srcFormat, dstUsage);
+
+    error = DoCopyTexSubImage(gl, target, level, writeX, writeY, zOffset, readX,
+                              readY, rwWidth, rwHeight);
+    if (error) {
+      errorText = nsPrintfCString(
+          "DoCopyTexSubImage(0x%04x, %i, %i,%i,%i, %i,%i, %u,%u) -> 0x%04x",
+          target.get(), level, writeX, writeY, zOffset, readX, readY, rwWidth,
+          rwHeight, error);
+      break;
+    }
+
+    return true;
+  } while (false);
+
+  if (error == LOCAL_GL_OUT_OF_MEMORY) {
+    webgl->ErrorOutOfMemory("Ran out of memory during texture copy.");
+    tex->Truncate();
+    return false;
+  }
+
+  if (gl->IsANGLE() && error == LOCAL_GL_INVALID_OPERATION) {
+    webgl->ErrorImplementationBug(
+        "ANGLE is particular about CopyTexSubImage"
+        " formats matching exactly.");
+    return false;
+  }
+
+  webgl->GenerateError(error, "Unexpected error from driver.");
+  gfxCriticalError() << "Unexpected error from driver: "
+                     << errorText.BeginReading();
+  return false;
+}
+
+// CopyTexSubImage if `!respecFormat`
+void WebGLTexture::CopyTexImage(GLenum imageTarget, uint32_t level,
+                                GLenum respecFormat, const uvec3& dstOffset,
+                                const ivec2& srcOffset, const uvec2& size2) {
+  ////////////////////////////////////
+  // Get source info
+
+  const webgl::FormatUsageInfo* srcUsage;
+  uint32_t srcTotalWidth;
+  uint32_t srcTotalHeight;
+  if (!mContext->BindCurFBForColorRead(&srcUsage, &srcTotalWidth,
+                                       &srcTotalHeight)) {
+    return;
+  }
+  const auto& srcFormat = srcUsage->format;
+
+  if (!ValidateCopyTexImageForFeedback(*mContext, *this, level, dstOffset.z))
+    return;
+
+  const auto size = uvec3{size2.x, size2.y, 1};
+
+  ////////////////////////////////////
+  // Get dest info
+
+  webgl::ImageInfo* imageInfo;
+  const webgl::FormatUsageInfo* dstUsage;
+  if (respecFormat) {
+    if (!ValidateTexImageSpecification(imageTarget, level, size, &imageInfo))
+      return;
+    MOZ_ASSERT(imageInfo);
+
+    dstUsage = ValidateCopyDestUsage(mContext, srcFormat, respecFormat);
+    if (!dstUsage) return;
+
+    if (!ValidateFormatAndSize(mContext, imageTarget, dstUsage->format, size))
+      return;
+  } else {
+    if (!ValidateTexImageSelection(imageTarget, level, dstOffset, size,
+                                   &imageInfo)) {
+      return;
+    }
+    MOZ_ASSERT(imageInfo);
+
+    dstUsage = imageInfo->mFormat;
+    MOZ_ASSERT(dstUsage);
+  }
+
+  const auto& dstFormat = dstUsage->format;
+  if (!mContext->IsWebGL2() && dstFormat->d) {
+    mContext->ErrorInvalidOperation(
+        "Function may not be called with format %s.", dstFormat->name);
+    return;
+  }
+
+  ////////////////////////////////////
+  // Check that source and dest info are compatible
+
+  if (!ValidateCopyTexImageFormats(mContext, srcFormat, dstFormat)) return;
+
+  ////////////////////////////////////
+  // Do the thing!
+
+  const bool isSubImage = !respecFormat;
+  bool expectsInit = true;
+  if (isSubImage) {
+    if (!EnsureImageDataInitializedForUpload(this, imageTarget, level,
+                                             dstOffset, size, imageInfo,
+                                             &expectsInit)) {
+      return;
+    }
+  }
+
+  if (!DoCopyTexOrSubImage(mContext, isSubImage, expectsInit, this, imageTarget,
+                           level, srcOffset.x, srcOffset.y, srcTotalWidth,
+                           srcTotalHeight, srcUsage, dstOffset.x, dstOffset.y,
+                           dstOffset.z, size.x, size.y, dstUsage)) {
+    Truncate();
+    return;
+  }
+
+  mContext->OnDataAllocCall();
+
+  ////////////////////////////////////
+  // Update our specification data?
+
+  if (respecFormat) {
+    const auto uninitializedSlices = Nothing();
+    const webgl::ImageInfo newImageInfo{dstUsage, size.x, size.y, size.z,
+                                        uninitializedSlices};
+    *imageInfo = newImageInfo;
+    InvalidateCaches();
+  }
+}
+
+}  // namespace mozilla