implement tex(Sub)Image2D/3D for HTMLVideoElement

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 5112 matching lines @@
     TexImageFunctionID functionID,
     GLenum target,
     GLint level,
     GLint internalformat,
     GLenum format,
     GLenum type,
     GLint xoffset,
     GLint yoffset,
     GLint zoffset,
     HTMLVideoElement* video,
+    const IntRect& sourceImageRect,
+    GLsizei depth,
+    GLint unpackImageHeight,
     ExceptionState& exceptionState) {
   const char* funcName = getTexImageFunctionName(functionID);
   if (isContextLost())
     return;
   if (!validateHTMLVideoElement(funcName, video, exceptionState))
     return;
   WebGLTexture* texture = validateTexImageBinding(funcName, functionID, target);
   if (!texture)
     return;
   TexImageFunctionType functionType;
-  if (functionID == TexImage2D)
+  if (functionID == TexImage2D || functionID == TexImage3D)
     functionType = TexImage;
   else
     functionType = TexSubImage;
   if (!validateTexFunc(funcName, functionType, SourceHTMLVideoElement, target,
                        level, internalformat, video->videoWidth(),
                        video->videoHeight(), 1, 0, format, type, xoffset,
                        yoffset, zoffset))
     return;
 
-  if (functionID == TexImage2D) {
+  bool sourceImageRectIsDefault =
+      sourceImageRect == sentinelEmptyRect() ||
+      sourceImageRect ==
+          IntRect(0, 0, video->videoWidth(), video->videoHeight());
+  if (functionID == TexImage2D && sourceImageRectIsDefault && depth == 1 &&
+      unpackImageHeight == 0) {
+    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(
               contextGL(), texture->object(), internalformat, type,
               m_unpackPremultiplyAlpha, m_unpackFlipY)) {
         return;
@@ skipping 36 matching lines @@
       }
     }
   }
 
   RefPtr<Image> image = videoFrameToImage(video);
   if (!image)
     return;
   texImageImpl(functionID, target, level, internalformat, xoffset, yoffset,
                zoffset, format, type, image.get(),
                WebGLImageConversion::HtmlDomVideo, m_unpackFlipY,
-               m_unpackPremultiplyAlpha,
-               IntRect(0, 0, video->videoWidth(), video->videoHeight()), 1, 0);
+               m_unpackPremultiplyAlpha, sourceImageRect, depth,
+               unpackImageHeight);
 }
 
 void WebGLRenderingContextBase::texImageBitmapByGPU(ImageBitmap* bitmap,
                                                     GLuint targetTexture,
                                                     GLenum targetInternalformat,
                                                     GLenum targetType,
                                                     GLint targetLevel,
                                                     bool flipY) {
   bitmap->bitmapImage()->copyToTexture(drawingBuffer()->contextProvider(),
                                        targetTexture, targetInternalformat,
                                        targetType, flipY);
 }
 
 void WebGLRenderingContextBase::texImage2D(GLenum target,
                                            GLint level,
                                            GLint internalformat,
                                            GLenum format,
                                            GLenum type,
                                            HTMLVideoElement* video,
                                            ExceptionState& exceptionState) {
   texImageHelperHTMLVideoElement(TexImage2D, target, level, internalformat,
-                                 format, type, 0, 0, 0, video, exceptionState);
+                                 format, type, 0, 0, 0, video,
+                                 sentinelEmptyRect(), 1, 0, exceptionState);
 }
 
 void WebGLRenderingContextBase::texImageHelperImageBitmap(
     TexImageFunctionID functionID,
     GLenum target,
     GLint level,
     GLint internalformat,
     GLenum format,
     GLenum type,
     GLint xoffset,
@@ skipping 238 matching lines @@
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target,
                                               GLint level,
                                               GLint xoffset,
                                               GLint yoffset,
                                               GLenum format,
                                               GLenum type,
                                               HTMLVideoElement* video,
                                               ExceptionState& exceptionState) {
   texImageHelperHTMLVideoElement(TexSubImage2D, target, level, 0, format, type,
-                                 xoffset, yoffset, 0, video, exceptionState);
+                                 xoffset, yoffset, 0, video,
+                                 sentinelEmptyRect(), 1, 0, exceptionState);
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target,
                                               GLint level,
                                               GLint xoffset,
                                               GLint yoffset,
                                               GLenum format,
                                               GLenum type,
                                               ImageBitmap* bitmap,
                                               ExceptionState& exceptionState) {
@@ skipping 2224 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(getOffscreenCanvas());
 }
 
 }  // namespace blink