Fix semantics of uploading HTML sources to 3D textures.

third_party/WebKit/Source/modules/webgl/WebGLRenderingContextBase.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 4385 matching lines @@
 
   WebGLImageConversion::DataFormat sourceDataFormat =
       imageExtractor.imageSourceFormat();
   WebGLImageConversion::AlphaOp alphaOp = imageExtractor.imageAlphaOp();
   const void* imagePixelData = imageExtractor.imagePixelData();
 
   bool needConversion = true;
   if (type == GL_UNSIGNED_BYTE &&
       sourceDataFormat == WebGLImageConversion::DataFormatRGBA8 &&
       format == GL_RGBA && alphaOp == WebGLImageConversion::AlphaDoNothing &&
-      !flipY && !selectingSubRectangle) {
+      !flipY && !selectingSubRectangle && depth == 1) {
     needConversion = false;
   } else {
     if (!WebGLImageConversion::packImageData(
             image, imagePixelData, format, type, flipY, alphaOp,
             sourceDataFormat, imageExtractor.imageWidth(),
-            imageExtractor.imageHeight(), adjustedSourceImageRect,
-            imageExtractor.imageSourceUnpackAlignment(), data)) {
+            imageExtractor.imageHeight(), adjustedSourceImageRect, depth,
+            imageExtractor.imageSourceUnpackAlignment(), unpackImageHeight,
+            data)) {
       synthesizeGLError(GL_INVALID_VALUE, funcName, "packImage error");
       return;
     }
   }
 
   resetUnpackParameters();
   if (functionID == TexImage2D) {
     texImage2DBase(target, level, internalformat,
                    adjustedSourceImageRect.width(),
                    adjustedSourceImageRect.height(), 0, format, type,
                    needConversion ? data.data() : imagePixelData);
   } else if (functionID == TexSubImage2D) {
     contextGL()->TexSubImage2D(target, level, xoffset, yoffset,
                                adjustedSourceImageRect.width(),
                                adjustedSourceImageRect.height(), format, type,
                                needConversion ? data.data() : imagePixelData);
   } else {
     // 3D functions.
-    GLint uploadHeight = adjustedSourceImageRect.height();
-    if (unpackImageHeight) {
-      // GL_UNPACK_IMAGE_HEIGHT overrides the passed-in height.
-      uploadHeight = unpackImageHeight;
-    }
     if (functionID == TexImage3D) {
-      contextGL()->TexImage3D(target, level, internalformat,
-                              adjustedSourceImageRect.width(), uploadHeight,
-                              depth, 0, format, type,
-                              needConversion ? data.data() : imagePixelData);
+      contextGL()->TexImage3D(
+          target, level, internalformat, adjustedSourceImageRect.width(),
+          adjustedSourceImageRect.height(), depth, 0, format, type,
+          needConversion ? data.data() : imagePixelData);
     } else {
       DCHECK_EQ(functionID, TexSubImage3D);
-      contextGL()->TexSubImage3D(target, level, xoffset, yoffset, zoffset,
-                                 adjustedSourceImageRect.width(), uploadHeight,
-                                 depth, format, type,
-                                 needConversion ? data.data() : imagePixelData);
+      contextGL()->TexSubImage3D(
+          target, level, xoffset, yoffset, zoffset,
+          adjustedSourceImageRect.width(), adjustedSourceImageRect.height(),
+          depth, format, type, needConversion ? data.data() : imagePixelData);
     }
   }
   restoreUnpackParameters();
 }
 
 bool WebGLRenderingContextBase::validateTexFunc(
     const char* functionName,
     TexImageFunctionType functionType,
     TexFuncValidationSourceType sourceType,
     GLenum target,
@@ skipping 175 matching lines @@
   if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {
     if (sourceType == Tex2D) {
       if (!WebGLImageConversion::extractTextureData(
               width, height, format, type, m_unpackAlignment, m_unpackFlipY,
               m_unpackPremultiplyAlpha, data, tempData))
         return;
       data = tempData.data();
     }
     changeUnpackAlignment = true;
   }
-  // FIXME: implement flipY and premultiplyAlpha for tex(Sub)3D.
+  // TODO(crbug.com/666064): implement flipY and premultiplyAlpha for
+  // tex(Sub)3D.
   if (functionID == TexImage3D) {
     contextGL()->TexImage3D(target, level,
                             convertTexInternalFormat(internalformat, type),
                             width, height, depth, border, format, type, data);
     return;
   }
   if (functionID == TexSubImage3D) {
     contextGL()->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width,
                                height, depth, format, type, data);
     return;
@@ skipping 73 matching lines @@
     adjustedSourceImageRect.setY(pixels->height() -
                                  adjustedSourceImageRect.maxY());
   }
 
   Vector<uint8_t> data;
   bool needConversion = true;
   // The data from ImageData is always of format RGBA8.
   // No conversion is needed if destination format is RGBA and type is
   // UNSIGNED_BYTE and no Flip or Premultiply operation is required.
   if (!m_unpackFlipY && !m_unpackPremultiplyAlpha && format == GL_RGBA &&
-      type == GL_UNSIGNED_BYTE && !selectingSubRectangle) {
+      type == GL_UNSIGNED_BYTE && !selectingSubRectangle && depth == 1) {
     needConversion = false;
   } else {
     if (type == GL_UNSIGNED_INT_10F_11F_11F_REV) {
       // The UNSIGNED_INT_10F_11F_11F_REV type pack/unpack isn't implemented.
       type = GL_FLOAT;
     }
     if (!WebGLImageConversion::extractImageData(
             pixels->data()->data(),
             WebGLImageConversion::DataFormat::DataFormatRGBA8, pixels->size(),
-            adjustedSourceImageRect, format, type, m_unpackFlipY,
-            m_unpackPremultiplyAlpha, data)) {
+            adjustedSourceImageRect, depth, unpackImageHeight, format, type,
+            m_unpackFlipY, m_unpackPremultiplyAlpha, data)) {
       synthesizeGLError(GL_INVALID_VALUE, funcName, "bad image data");
       return;
     }
   }
   resetUnpackParameters();
   const uint8_t* bytes = needConversion ? data.data() : pixels->data()->data();
   if (functionID == TexImage2D) {
     DCHECK_EQ(unpackImageHeight, 0);
     texImage2DBase(
         target, level, internalformat, adjustedSourceImageRect.width(),
@@ skipping 265 matching lines @@
   // Note that the sub-rectangle validation is needed for the GPU-GPU
   // copy case, but is redundant for the software upload case
   // (texImageImpl).
   bool selectingSubRectangle = false;
   if (!validateTexImageSubRectangle(
           funcName, functionID, canvas, sourceSubRectangle, depth,
           unpackImageHeight, &selectingSubRectangle)) {
     return;
   }
 
-  if (functionID == TexImage3D || functionID == TexSubImage3D) {
-    DCHECK_GE(unpackImageHeight, 0);
-
-    // Verify that the image data can cover the required depth.
-    CheckedNumeric<GLint> maxDepthSupported = 1;
-    if (unpackImageHeight) {
-      maxDepthSupported = sourceSubRectangle.height();
-      maxDepthSupported /= unpackImageHeight;
-    }
-
-    if (!maxDepthSupported.IsValid() ||
-        maxDepthSupported.ValueOrDie() < depth) {
-      synthesizeGLError(
-          GL_INVALID_OPERATION, funcName,
-          "Not enough data supplied to upload to a 3D texture with depth > 1");
-      return;
-    }
-  } else {
-    DCHECK_EQ(depth, 1);
-    DCHECK_EQ(unpackImageHeight, 0);
-  }
-
   if (functionID == TexImage2D || functionID == TexSubImage2D) {
     // texImageByGPU relies on copyTextureCHROMIUM which doesn't support
     // float/integer/sRGB internal format.
     // TODO(crbug.com/622958): relax the constrains if copyTextureCHROMIUM is
     // upgraded to handle more formats.
     if (!canvas->renderingContext() ||
         !canvas->renderingContext()->isAccelerated() ||
         !canUseTexImageByGPU(functionID, internalformat, type)) {
       // 2D canvas has only FrontBuffer.
       texImageImpl(functionID, target, level, internalformat, xoffset, yoffset,
@@ skipping 91 matching lines @@
   if (!validateTexFunc(funcName, functionType, SourceHTMLVideoElement, target,
                        level, internalformat, video->videoWidth(),
                        video->videoHeight(), 1, 0, format, type, xoffset,
                        yoffset, zoffset))
     return;
 
   bool sourceImageRectIsDefault =
       sourceImageRect == sentinelEmptyRect() ||
       sourceImageRect ==
           IntRect(0, 0, video->videoWidth(), video->videoHeight());
-  if (functionID == TexImage2D && sourceImageRectIsDefault && depth == 1 &&
-      unpackImageHeight == 0) {
+  if (functionID == TexImage2D && sourceImageRectIsDefault && depth == 1) {
     DCHECK_EQ(xoffset, 0);
     DCHECK_EQ(yoffset, 0);
     DCHECK_EQ(zoffset, 0);
     // Go through the fast path doing a GPU-GPU textures copy without a readback
     // to system memory if possible.  Otherwise, it will fall back to the normal
     // SW path.
     if (GL_TEXTURE_2D == target) {
       if (Extensions3DUtil::canUseCopyTextureCHROMIUM(target, internalformat,
                                                       type, level) &&
           video->copyVideoTextureToPlatformTexture(
@@ skipping 111 matching lines @@
     functionType = TexSubImage;
 
   GLsizei width = sourceSubRect.width();
   GLsizei height = sourceSubRect.height();
   if (!validateTexFunc(funcName, functionType, SourceImageBitmap, target, level,
                        internalformat, width, height, depth, 0, format, type,
                        xoffset, yoffset, zoffset))
     return;
   ASSERT(bitmap->bitmapImage());
 
+  // TODO(kbr): make this work for sub-rectangles of ImageBitmaps.
   if (functionID != TexSubImage3D && functionID != TexImage3D &&
       bitmap->isAccelerated() &&
       canUseTexImageByGPU(functionID, internalformat, type) &&
       !selectingSubRectangle) {
     if (functionID == TexImage2D) {
       texImage2DBase(target, level, internalformat, width, height, 0, format,
                      type, 0);
       texImageByGPU(TexImage2DByGPU, texture, target, level, internalformat,
                     type, 0, 0, 0, bitmap, sourceSubRect);
     } else if (functionID == TexSubImage2D) {
@@ skipping 17 matching lines @@
         bitmap->isPremultiplied() ? PremultiplyAlpha : DontPremultiplyAlpha);
     pixelDataPtr = pixelData->data();
   }
   Vector<uint8_t> data;
   bool needConversion = true;
   bool havePeekableRGBA =
       (peekSucceed &&
        pixmap.colorType() == SkColorType::kRGBA_8888_SkColorType);
   bool isPixelDataRGBA = (havePeekableRGBA || !peekSucceed);
   if (isPixelDataRGBA && format == GL_RGBA && type == GL_UNSIGNED_BYTE &&
-      !selectingSubRectangle) {
+      !selectingSubRectangle && depth == 1) {
     needConversion = false;
   } else {
     if (type == GL_UNSIGNED_INT_10F_11F_11F_REV) {
       // The UNSIGNED_INT_10F_11F_11F_REV type pack/unpack isn't implemented.
       type = GL_FLOAT;
     }
     // In the case of ImageBitmap, we do not need to apply flipY or
     // premultiplyAlpha.
     bool isPixelDataBGRA =
         pixmap.colorType() == SkColorType::kBGRA_8888_SkColorType;
     if ((isPixelDataBGRA &&
          !WebGLImageConversion::extractImageData(
              pixelDataPtr, WebGLImageConversion::DataFormat::DataFormatBGRA8,
-             bitmap->size(), sourceSubRect, format, type, false, false,
-             data)) ||
+             bitmap->size(), sourceSubRect, depth, unpackImageHeight, format,
+             type, false, false, data)) ||
         (isPixelDataRGBA &&
          !WebGLImageConversion::extractImageData(
              pixelDataPtr, WebGLImageConversion::DataFormat::DataFormatRGBA8,
-             bitmap->size(), sourceSubRect, format, type, false, false,
-             data))) {
+             bitmap->size(), sourceSubRect, depth, unpackImageHeight, format,
+             type, false, false, data))) {
       synthesizeGLError(GL_INVALID_VALUE, funcName, "bad image data");
       return;
     }
   }
   resetUnpackParameters();
   if (functionID == TexImage2D) {
     texImage2DBase(target, level, internalformat, width, height, 0, format,
                    type, needConversion ? data.data() : pixelDataPtr);
   } else if (functionID == TexSubImage2D) {
     contextGL()->TexSubImage2D(target, level, xoffset, yoffset, width, height,
@@ skipping 2421 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(getOffscreenCanvas());
 }
 
 }  // namespace blink