support 3d texture sub-source uploads from ImageData

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

 /*
  * 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 31 matching lines @@
 #include "modules/webgl/WebGLTexture.h"
 #include "modules/webgl/WebGLVertexArrayObjectBase.h"
 #include "platform/Timer.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/gpu/DrawingBuffer.h"
 #include "platform/graphics/gpu/Extensions3DUtil.h"
 #include "platform/graphics/gpu/WebGLImageConversion.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebGraphicsContext3DProvider.h"
 #include "third_party/khronos/GLES2/gl2.h"
+#include "wtf/CheckedNumeric.h"
 #include "wtf/text/WTFString.h"
 #include <memory>
 #include <set>
 
 namespace blink {
 class WebLayer;
 }
 
 namespace gpu {
 namespace gles2 {
@@ skipping 955 matching lines @@
                     GLenum type,
                     Image*,
                     WebGLImageConversion::ImageHtmlDomSource,
                     bool flipY,
                     bool premultiplyAlpha,
                     const IntRect&,
                     GLsizei depth,
                     GLint unpackImageHeight);
   template <typename T>
   bool validateTexImageSubRectangle(const char* functionName,
+                                    TexImageFunctionID functionID,
                                     T* image,
                                     const IntRect& subRect,
+                                    GLsizei depth,
+                                    GLint unpackImageHeight,
                                     bool* selectingSubRectangle) {
+    DCHECK(functionName);
+    DCHECK(selectingSubRectangle);
+    DCHECK(image);
     *selectingSubRectangle = image &&
                              !(subRect.x() == 0 && subRect.y() == 0 &&
                                subRect.width() == image->width() &&
                                subRect.height() == image->height());
     // If the source image rect selects anything except the entire
     // contents of the image, assert that we're running WebGL 2.0 or
     // higher, since this should never happen for WebGL 1.0 (even though
     // the code could support it). If the image is null, that will be
     // signaled as an error later.
     DCHECK(!*selectingSubRectangle || isWebGL2OrHigher())
         << "subRect = (" << subRect.width() << " x " << subRect.height()
         << ") @ (" << subRect.x() << ", " << subRect.y() << "), image = ("
         << (image ? image->width() : -1) << " x "
         << (image ? image->height() : -1) << ")";
 
     if (subRect.x() < 0 || subRect.y() < 0 || subRect.maxX() > image->width() ||
         subRect.maxY() > image->height() || subRect.width() < 0 ||
         subRect.height() < 0) {
       synthesizeGLError(GL_INVALID_OPERATION, functionName,
                         "source sub-rectangle specified via pixel unpack "
                         "parameters is invalid");
       return false;
     }
+
+    if (functionID == TexImage3D || functionID == TexSubImage3D) {
+      DCHECK_GE(unpackImageHeight, 0);
+
+      // Verify that the image data can cover the required depth.
+      WTF::CheckedNumeric<GLint> maxDepthSupported = 1;
+      if (unpackImageHeight) {
+        maxDepthSupported = subRect.height();
+        maxDepthSupported /= unpackImageHeight;
+      }
+
+      if (!maxDepthSupported.IsValid() ||
+          maxDepthSupported.ValueOrDie() < depth) {
+        synthesizeGLError(GL_INVALID_OPERATION, functionName,
+                          "Not enough data supplied to upload to a 3D texture "
+                          "with depth > 1");
+        return false;
+      }
+    } else {
+      DCHECK_EQ(depth, 1);
+      DCHECK_EQ(unpackImageHeight, 0);
+    }
     return true;
   }
 
   // Copy from the source directly to the texture via the gpu, without a
   // read-back to system memory.  Souce could be canvas or imageBitmap.
   void texImageByGPU(TexImageByGPUType,
                      WebGLTexture*,
                      GLenum target,
                      GLint level,
                      GLint internalformat,
@@ skipping 441 matching lines @@
                                GLint,
                                GLint,
                                GLint,
                                GLenum,
                                GLenum,
                                GLsizei,
                                GLint,
                                GLint,
                                GLint,
                                ImageData*,
-                               const IntRect&);
+                               const IntRect&,
+                               GLint);
   void texImageHelperHTMLImageElement(TexImageFunctionID,
                                       GLenum,
                                       GLint,
                                       GLint,
                                       GLenum,
                                       GLenum,
                                       GLint,
                                       GLint,
                                       GLint,
                                       HTMLImageElement*,
@@ skipping 73 matching lines @@
                   context,
                   context->is3d(),
                   context.is3d());
 
 }  // namespace blink
 
 WTF_ALLOW_MOVE_INIT_AND_COMPARE_WITH_MEM_FUNCTIONS(
     blink::WebGLRenderingContextBase::TextureUnitState);
 
 #endif  // WebGLRenderingContextBase_h