Pack repeated code in tex(Sub)Image2D and texSubImage3D into helper func

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 4033 matching lines @@
     if (!image->currentFrameKnownToBeOpaque())
         buf->canvas()->clear(SK_ColorTRANSPARENT);
 
     IntRect srcRect(IntPoint(), image->size());
     IntRect destRect(0, 0, size.width(), size.height());
     SkPaint paint;
     image->draw(buf->canvas(), paint, destRect, srcRect, DoNotRespectImageOrientation, Image::DoNotClampImageToSourceRect);
     return buf->newImageSnapshot();
 }
 
+void WebGLRenderingContextBase::texImageHelperDOMArrayBufferView(const char* funcType, GLenum target, GLint level, GLint internalformat,

[Zhenyao Mo, 2016/05/31 16:37:33]

This should be named funcName to be consistent with other functions.

+    GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, GLsizei depth,
+    GLint xoffset, GLint yoffset, GLint zoffset, DOMArrayBufferView* pixels)
+{
+    if (isContextLost())
+        return;
+    if ((!strcmp(funcType, "texImage2D") || !strcmp(funcType, "texSubImage2D")) && !validateTexture2DBinding(funcType, target))

[Zhenyao Mo, 2016/05/31 16:37:33]

To me, you can make a virtual function validateTextureBinding(), and in WebGL 1,
you only deal the 2D binding, and in WebGL 2, you deal with both 2D and 3D
bindings, depending on the function. This way, we don't have to expose
validateTexture3DBinding in the WebGL 1 context, which to me is really ugly.

+        return;
+    if ((!strcmp(funcType, "texImage3D") || !strcmp(funcType, "texSubImage3D")) && !validateTexture3DBinding(funcType, target))
+        return;
+    TexImageFunctionType functionType;
+    if (!strcmp(funcType, "texImage2D") || !strcmp(funcType, "texImage3D"))
+        functionType = TexImage;
+    else
+        functionType = TexSubImage;
+    if (!validateTexFunc(funcType, functionType, SourceArrayBufferView, target, level, internalformat, width, height, depth, border, format, type, xoffset, yoffset, zoffset))
+        return;
+    TexImageDimension sourceType;
+    if (!strcmp(funcType, "texImage2D") || !strcmp(funcType, "texSubImage2D"))

[Zhenyao Mo, 2016/05/31 16:37:33]

Can you find a way not to do all these duplicated strcmp? Even though it may not
be heavy, but we should still strive to optimize the code, even a small piece.

[xidachen, 2016/05/31 17:15:43]

Thank you for pointing it out. Just realized that I have injected a whole bunch
of strcmp here.

What about instead of passing a const char*, I pass an enum, and use switch
here? Would that be better?

+        sourceType = Tex2D;
+    else
+        sourceType = Tex3D;
+    if (!validateTexFuncData(funcType, sourceType, level, width, height, depth, format, type, pixels, NullAllowed))
+        return;
+    void* data = pixels ? pixels->baseAddress() : 0;
+    Vector<uint8_t> tempData;
+    bool changeUnpackAlignment = false;
+    if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {
+        if (!strcmp(funcType, "texImage2D") || !strcmp(funcType, "texSubImage2D")) {
+            if (!WebGLImageConversion::extractTextureData(width, height, format, type, m_unpackAlignment, m_unpackFlipY, m_unpackPremultiplyAlpha, data, tempData))
+                return;
+            data = tempData.data();
+        } else {
+            NOTIMPLEMENTED();
+            if (!strcmp(funcType, "texImage3D"))
+                return;
+        }
+        changeUnpackAlignment = true;
+    }
+    if (!strcmp(funcType, "texImage3D")) {
+        contextGL()->TexImage3D(target, level, convertTexInternalFormat(internalformat, type), width, height, depth, border, format, type, data);
+        return;
+    }
+
+    if (changeUnpackAlignment)
+        resetUnpackParameters();
+    if (!strcmp(funcType, "texImage2D"))
+        texImage2DBase(target, level, internalformat, width, height, border, format, type, data);
+    else if (!strcmp(funcType, "texSubImage2D"))
+        contextGL()->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, data);
+    else
+        contextGL()->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
+    if (changeUnpackAlignment)
+        restoreUnpackParameters();
+}
+
 void WebGLRenderingContextBase::texImage2D(GLenum target, GLint level, GLint internalformat,
     GLsizei width, GLsizei height, GLint border,
     GLenum format, GLenum type, DOMArrayBufferView* pixels)
 {
-    if (isContextLost())
-        return;
-    if (!validateTexture2DBinding("texImage2D", target))
-        return;
-    if (!validateTexFunc("texImage2D", TexImage, SourceArrayBufferView, target, level, internalformat, width, height, 1, border, format, type, 0, 0, 0))
-        return;
-    if (!validateTexFuncData("texImage2D", Tex2D, level, width, height, 1, format, type, pixels, NullAllowed))
-        return;
-    void* data = pixels ? pixels->baseAddress() : 0;
-    Vector<uint8_t> tempData;
-    bool changeUnpackAlignment = false;
-    if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {
-        if (!WebGLImageConversion::extractTextureData(width, height, format, type, m_unpackAlignment, m_unpackFlipY, m_unpackPremultiplyAlpha, data, tempData))
-            return;
-        data = tempData.data();
-        changeUnpackAlignment = true;
-    }
-    if (changeUnpackAlignment)
-        resetUnpackParameters();
-    texImage2DBase(target, level, internalformat, width, height, border, format, type, data);
-    if (changeUnpackAlignment)
-        restoreUnpackParameters();
+    texImageHelperDOMArrayBufferView("texImage2D", target, level, internalformat, width, height, border, format, type, 1, 0, 0, 0, pixels);
 }
 
-void WebGLRenderingContextBase::texImage2D(GLenum target, GLint level, GLint internalformat,
-    GLenum format, GLenum type, ImageData* pixels)
+void WebGLRenderingContextBase::texImageHelperImageData(const char* funcType, GLenum target, GLint level, GLint internalformat,
+    GLint border, GLenum format, GLenum type, GLsizei depth,
+    GLint xoffset, GLint yoffset, GLint zoffset, ImageData* pixels)
 {
     if (isContextLost())
         return;
     if (!pixels) {
-        synthesizeGLError(GL_INVALID_VALUE, "texImage2D", "no image data");
+        synthesizeGLError(GL_INVALID_VALUE, funcType, "no image data");
         return;
     }
     if (pixels->data()->bufferBase()->isNeutered()) {
-        synthesizeGLError(GL_INVALID_VALUE, "texImage2D", "The source data has been neutered.");
+        synthesizeGLError(GL_INVALID_VALUE, funcType, "The source data has been neutered.");
         return;
     }
-    if (!validateTexture2DBinding("texImage2D", target))
+    if ((!strcmp(funcType, "texImage2D") || !strcmp(funcType, "texSubImage2D")) && !validateTexture2DBinding(funcType, target))
         return;
-    if (!validateTexFunc("texImage2D", TexImage, SourceImageData, target, level, internalformat, pixels->width(), pixels->height(), 1, 0, format, type, 0, 0, 0))
+    if (!strcmp(funcType, "texSubImage3D") && !validateTexture3DBinding(funcType, target))
+        return;
+    TexImageFunctionType functionType;
+    if (!strcmp(funcType, "texImage2D"))
+        functionType = TexImage;
+    else
+        functionType = TexSubImage;
+    if (!validateTexFunc(funcType, functionType, SourceImageData, target, level, internalformat, pixels->width(), pixels->height(), depth, border, format, type, xoffset, yoffset, zoffset))
         return;
     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 USIGNED_BYTE and no Flip or Premultiply operation is required.
     if (!m_unpackFlipY && !m_unpackPremultiplyAlpha && format == GL_RGBA && type == GL_UNSIGNED_BYTE) {
         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(), format, type, m_unpackFlipY, m_unpackPremultiplyAlpha, data)) {
-            synthesizeGLError(GL_INVALID_VALUE, "texImage2D", "bad image data");
+            synthesizeGLError(GL_INVALID_VALUE, funcType, "bad image data");
             return;
         }
     }
     resetUnpackParameters();
-    texImage2DBase(target, level, internalformat, pixels->width(), pixels->height(), 0, format, type, needConversion ? data.data() : pixels->data()->data());
+    if (!strcmp(funcType, "texImage2D"))
+        texImage2DBase(target, level, internalformat, pixels->width(), pixels->height(), border, format, type, needConversion ? data.data() : pixels->data()->data());
+    else if (!strcmp(funcType, "texSubImage2D"))
+        contextGL()->TexSubImage2D(target, level, xoffset, yoffset, pixels->width(), pixels->height(), format, type, needConversion ? data.data() : pixels->data()->data());
+    else // must be "texSubImage3D"
+        contextGL()->TexSubImage3D(target, level, xoffset, yoffset, zoffset, pixels->width(), pixels->height(), depth, format, type, needConversion ? data.data() : pixels->data()->data());
     restoreUnpackParameters();
 }
 
 void WebGLRenderingContextBase::texImage2D(GLenum target, GLint level, GLint internalformat,
+    GLenum format, GLenum type, ImageData* pixels)
+{
+    texImageHelperImageData("texImage2D", target, level, internalformat, 0, format, type, 1, 0, 0, 0, pixels);
+}
+
+bool WebGLRenderingContextBase::texImageHelperHTMLImageElement(const char* funcType, GLenum target, GLint level, GLint internalformat,
+    GLenum format, GLenum type, GLint xoffset, GLint yoffset, GLint zoffset, HTMLImageElement* image, ExceptionState& exceptionState)
+{
+    if (isContextLost())
+        return false;
+    if (!validateHTMLImageElement(funcType, image, exceptionState))
+        return false;
+    if ((!strcmp(funcType, "texImage2D") || !strcmp(funcType, "texSubImage2D")) && !validateTexture2DBinding(funcType, target))
+        return false;
+    if (!strcmp(funcType, "texSubImage3D") && !validateTexture3DBinding(funcType, target))
+        return false;
+    if (!strcmp(funcType, "texSubImage3D"))
+        return true;
+
+    RefPtr<Image> imageForRender = image->cachedImage()->getImage();
+    if (imageForRender && imageForRender->isSVGImage())
+        imageForRender = drawImageIntoBuffer(imageForRender.release(), image->width(), image->height(), funcType);
+
+    TexImageFunctionType functionType;
+    if (!strcmp(funcType, "texImage2D"))
+        functionType = TexImage;
+    else
+        functionType = TexSubImage;
+    if (!imageForRender || !validateTexFunc(funcType, functionType, SourceHTMLImageElement, target, level, internalformat, imageForRender->width(), imageForRender->height(), 1, 0, format, type, xoffset, yoffset, zoffset))
+        return false;
+
+    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 (!strcmp(funcType, "texImage2D"))
+        texImage2DImpl(target, level, internalformat, format, type, imageForRender.get(), WebGLImageConversion::HtmlDomImage, m_unpackFlipY, m_unpackPremultiplyAlpha);
+    else if (!strcmp(funcType, "texSubImage2D"))
+        texSubImage2DImpl(target, level, xoffset, yoffset, format, type, imageForRender.get(), WebGLImageConversion::HtmlDomImage, m_unpackFlipY, m_unpackPremultiplyAlpha);
+    return true;
+}
+
+void WebGLRenderingContextBase::texImage2D(GLenum target, GLint level, GLint internalformat,
     GLenum format, GLenum type, HTMLImageElement* image, ExceptionState& exceptionState)
 {
-    if (isContextLost())
-        return;
-    if (!validateHTMLImageElement("texImage2D", image, exceptionState))
-        return;
-    if (!validateTexture2DBinding("texImage2D", target))
-        return;
-
-    RefPtr<Image> imageForRender = image->cachedImage()->getImage();
-    if (imageForRender && imageForRender->isSVGImage())
-        imageForRender = drawImageIntoBuffer(imageForRender.release(), image->width(), image->height(), "texImage2D");
-
-    if (!imageForRender || !validateTexFunc("texImage2D", TexImage, SourceHTMLImageElement, target, level, internalformat, imageForRender->width(), imageForRender->height(), 1, 0, format, type, 0, 0, 0))
-        return;
-
-    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;
-    }
-    texImage2DImpl(target, level, internalformat, format, type, imageForRender.get(), WebGLImageConversion::HtmlDomImage, m_unpackFlipY, m_unpackPremultiplyAlpha);
+    texImageHelperHTMLImageElement("texImage2D", target, level, internalformat, format, type, 0, 0, 0, image, exceptionState);
 }
 
 bool WebGLRenderingContextBase::canUseTexImageCanvasByGPU(GLint internalformat, GLenum type)
 {
     if (isFloatType(type) || isIntegerFormat(internalformat) || isSRGBFormat(internalformat))
         return false;
     return true;
 }
 
 void WebGLRenderingContextBase::texImageCanvasByGPU(TexImageByGPUType functionType, WebGLTexture* texture, GLenum target,
@@ skipping 53 matching lines @@
         } else if (functionType == TexSubImage3DByGPU) {
             contextGL()->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, 0, 0, canvas->width(), canvas->height());
         }
         contextGL()->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
         restoreCurrentFramebuffer();
         contextGL()->DeleteFramebuffers(1, &tmpFBO);
         contextGL()->DeleteTextures(1, &targetTexture);
     }
 }
 
+WebGLTexture* WebGLRenderingContextBase::texImageHelperHTMLCanvasElement(const char* funcType, GLenum target, GLint level, GLint internalformat,
+    GLenum format, GLenum type, GLint xoffset, GLint yoffset, GLint zoffset, HTMLCanvasElement* canvas, ExceptionState& exceptionState)
+{
+    if (isContextLost())
+        return nullptr;
+    if (!validateHTMLCanvasElement(funcType, canvas, exceptionState))
+        return nullptr;
+    WebGLTexture* texture = nullptr;
+    if (!strcmp(funcType, "texImage2D") || !strcmp(funcType, "texSubImage2D"))
+        texture = validateTexture2DBinding(funcType, target);
+    else
+        texture = validateTexture3DBinding(funcType, target);
+    if (!texture)
+        return nullptr;
+    TexImageFunctionType functionType;
+    if (!strcmp(funcType, "texImage2D"))
+        functionType = TexImage;
+    else
+        functionType = TexSubImage;
+    if (!validateTexFunc(funcType, functionType, SourceHTMLCanvasElement, target, level, internalformat, canvas->width(), canvas->height(), 1, 0, format, type, xoffset, yoffset, zoffset))
+        return nullptr;
+    return texture;
+}
+
 void WebGLRenderingContextBase::texImage2D(GLenum target, GLint level, GLint internalformat,
     GLenum format, GLenum type, HTMLCanvasElement* canvas, ExceptionState& exceptionState)
 {
-    if (isContextLost())
-        return;
-    if (!validateHTMLCanvasElement("texImage2D", canvas, exceptionState))
-        return;
-    WebGLTexture* texture = validateTexture2DBinding("texImage2D", target);
+    WebGLTexture* texture = texImageHelperHTMLCanvasElement("texImage2D", target, level, internalformat, format, type, 0, 0, 0, canvas, exceptionState);
     if (!texture)
         return;
-    if (!validateTexFunc("texImage2D", TexImage, SourceHTMLCanvasElement, target, level, internalformat, canvas->width(), canvas->height(), 1, 0, format, type, 0, 0, 0))
-        return;
-
     // texImageCanvasByGPU relies on copyTextureCHROMIUM which doesn't support float/integer/sRGB internal format.
     // FIXME: relax the constrains if copyTextureCHROMIUM is upgraded to handle more formats.
     if (!canvas->renderingContext() || !canvas->renderingContext()->isAccelerated() || !canUseTexImageCanvasByGPU(internalformat, type)) {
         // 2D canvas has only FrontBuffer.
         texImage2DImpl(target, level, internalformat, format, type, canvas->copiedImage(FrontBuffer, PreferAcceleration).get(),
             WebGLImageConversion::HtmlDomCanvas, m_unpackFlipY, m_unpackPremultiplyAlpha);
         return;
     }
 
     texImage2DBase(target, level, internalformat, canvas->width(), canvas->height(), 0, format, type, 0);
     texImageCanvasByGPU(TexImage2DByGPU, texture, target, level, internalformat, type, 0, 0, 0, canvas);
 }
 
 PassRefPtr<Image> WebGLRenderingContextBase::videoFrameToImage(HTMLVideoElement* video)
 {
     IntSize size(video->videoWidth(), video->videoHeight());
     ImageBuffer* buf = m_generatedImageCache.imageBuffer(size);
     if (!buf) {
         synthesizeGLError(GL_OUT_OF_MEMORY, "texImage2D", "out of memory");
         return nullptr;
     }
     IntRect destRect(0, 0, size.width(), size.height());
     video->paintCurrentFrame(buf->canvas(), destRect, nullptr);
     return buf->newImageSnapshot();
 }
 
+WebGLTexture* WebGLRenderingContextBase::texImageHelperHTMLVideoElement(const char* funcType, GLenum target, GLint level, GLint internalformat,
+    GLenum format, GLenum type, GLint xoffset, GLint yoffset, GLint zoffset, HTMLVideoElement* video, ExceptionState& exceptionState)
+{
+    if (isContextLost())
+        return nullptr;
+    if (!validateHTMLVideoElement(funcType, video, exceptionState))
+        return nullptr;
+    WebGLTexture* texture = nullptr;
+    if (!strcmp(funcType, "texImage2D") || !strcmp(funcType, "texSubImage2D"))
+        texture = validateTexture2DBinding(funcType, target);
+    else
+        texture = validateTexture3DBinding(funcType, target);
+    if (!texture)
+        return nullptr;
+    TexImageFunctionType functionType;
+    if (!strcmp(funcType, "texImage2D"))
+        functionType = TexImage;
+    else
+        functionType = TexSubImage;
+    if (!validateTexFunc(funcType, functionType, SourceHTMLVideoElement, target, level, internalformat, video->videoWidth(), video->videoHeight(), 1, 0, format, type, xoffset, yoffset, zoffset))
+        return nullptr;
+    return texture;
+}
+
 void WebGLRenderingContextBase::texImage2D(GLenum target, GLint level, GLint internalformat,
     GLenum format, GLenum type, HTMLVideoElement* video, ExceptionState& exceptionState)
 {
-    if (isContextLost())
-        return;
-    if (!validateHTMLVideoElement("texImage2D", video, exceptionState))
-        return;
-    WebGLTexture* texture = validateTexture2DBinding("texImage2D", target);
+    WebGLTexture* texture = texImageHelperHTMLVideoElement("texImage2D", target, level, internalformat, format, type, 0, 0, 0, video, exceptionState);
     if (!texture)
         return;
-    if (!validateTexFunc("texImage2D", TexImage, SourceHTMLVideoElement, target, level, internalformat, video->videoWidth(), video->videoHeight(), 1, 0, format, type, 0, 0, 0))
-        return;
-
     // 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;
         }
 
         // Try using an accelerated image buffer, this allows YUV conversion to be done on the GPU.
         OwnPtr<ImageBufferSurface> surface = adoptPtr(new AcceleratedImageBufferSurface(IntSize(video->videoWidth(), video->videoHeight())));
@@ skipping 14 matching lines @@
         }
     }
 
     // Normal pure SW path.
     RefPtr<Image> image = videoFrameToImage(video);
     if (!image)
         return;
     texImage2DImpl(target, level, internalformat, format, type, image.get(), WebGLImageConversion::HtmlDomVideo, m_unpackFlipY, m_unpackPremultiplyAlpha);
 }
 
-void WebGLRenderingContextBase::texImage2D(GLenum target, GLint level, GLint internalformat,
-    GLenum format, GLenum type, ImageBitmap* bitmap, ExceptionState& exceptionState)
+void WebGLRenderingContextBase::texImageHelperImageBitmap(const char* funcType, GLenum target, GLint level, GLint internalformat,
+    GLenum format, GLenum type, GLint xoffset, GLint yoffset, GLint zoffset, ImageBitmap* bitmap, ExceptionState& exceptionState)
 {
     if (isContextLost())
         return;
-    if (!validateImageBitmap("texImage2D", bitmap, exceptionState))
+    if (!validateImageBitmap(funcType, bitmap, exceptionState))
         return;
-    if (!validateTexture2DBinding("texImage2D", target))
+    if ((!strcmp(funcType, "texImage2D") || !strcmp(funcType, "texSubImage2D")) && !validateTexture2DBinding(funcType, target))
         return;
-    if (!validateTexFunc("texImage2D", TexImage, SourceImageBitmap, target, level, internalformat, bitmap->width(), bitmap->height(), 1, 0, format, type, 0, 0, 0))
+    if (!strcmp(funcType, "texSubImage3D") && !validateTexture3DBinding(funcType, target))
+        return;
+    TexImageFunctionType functionType;
+    if (!strcmp(funcType, "texImage2D"))
+        functionType = TexImage;
+    else
+        functionType = TexSubImage;
+    if (!validateTexFunc(funcType, functionType, SourceImageBitmap, target, level, internalformat, bitmap->width(), bitmap->height(), 1, 0, format, type, xoffset, yoffset, zoffset))
         return;
     ASSERT(bitmap->bitmapImage());
     RefPtr<SkImage> skImage = bitmap->bitmapImage()->imageForCurrentFrame();
     SkPixmap pixmap;
     OwnPtr<uint8_t[]> pixelData;
     uint8_t* pixelDataPtr = nullptr;
     // TODO(crbug.com/613411): peekPixels fails if the SkImage is texture-backed
     // Use texture mailbox in that case.
     bool peekSucceed = skImage->peekPixels(&pixmap);
     if (peekSucceed) {
@@ skipping 10 matching lines @@
         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 = (peekSucceed && pixmap.colorType() == SkColorType::kBGRA_8888_SkColorType);
         if ((isPixelDataBGRA && !WebGLImageConversion::extractImageData(pixelDataPtr, WebGLImageConversion::DataFormat::DataFormatBGRA8, bitmap->size(), format, type, false, false, data))
             || (isPixelDataRBGA && !WebGLImageConversion::extractImageData(pixelDataPtr, WebGLImageConversion::DataFormat::DataFormatRGBA8, bitmap->size(), format, type, false, false, data))) {
-            synthesizeGLError(GL_INVALID_VALUE, "texImage2D", "bad image data");
+            synthesizeGLError(GL_INVALID_VALUE, funcType, "bad image data");
             return;
         }
     }
     resetUnpackParameters();
-    texImage2DBase(target, level, internalformat, bitmap->width(), bitmap->height(), 0, format, type, needConversion ? data.data() : pixelDataPtr);
+    if (!strcmp(funcType, "texImage2D"))
+        texImage2DBase(target, level, internalformat, bitmap->width(), bitmap->height(), 0, format, type, needConversion ? data.data() : pixelDataPtr);
+    else if (!strcmp(funcType, "texSubImage2D"))
+        contextGL()->TexSubImage2D(target, level, xoffset, yoffset, bitmap->width(), bitmap->height(), format, type, needConversion ? data.data() : pixelDataPtr);
+    else // must be "texSubImage3D"
+        contextGL()->TexSubImage3D(target, level, xoffset, yoffset, zoffset, bitmap->width(), bitmap->height(), 1, format, type, needConversion ? data.data() : pixelDataPtr);
     restoreUnpackParameters();
 }
 
+void WebGLRenderingContextBase::texImage2D(GLenum target, GLint level, GLint internalformat,
+    GLenum format, GLenum type, ImageBitmap* bitmap, ExceptionState& exceptionState)
+{
+    texImageHelperImageBitmap("texImage2D", target, level, internalformat, format, type, 0, 0, 0, bitmap, exceptionState);
+}
+
 void WebGLRenderingContextBase::texParameter(GLenum target, GLenum pname, GLfloat paramf, GLint parami, bool isFloat)
 {
     if (isContextLost())
         return;
     if (!validateTextureBinding("texParameter", target))
         return;
     switch (pname) {
     case GL_TEXTURE_MIN_FILTER:
     case GL_TEXTURE_MAG_FILTER:
         break;
@@ skipping 78 matching lines @@
 
     resetUnpackParameters();
     contextGL()->TexSubImage2D(target, level, xoffset, yoffset, imageExtractor.imageWidth(), imageExtractor.imageHeight(), format, type,  needConversion ? data.data() : imagePixelData);
     restoreUnpackParameters();
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
     GLsizei width, GLsizei height,
     GLenum format, GLenum type, DOMArrayBufferView* pixels)
 {
-    if (isContextLost())
-        return;
-    if (!validateTexture2DBinding("texSubImage2D", target))
-        return;
-    if (!validateTexFunc("texSubImage2D", TexSubImage, SourceArrayBufferView, target, level, 0, width, height, 1, 0, format, type, xoffset, yoffset, 0))
-        return;
-    if (!validateTexFuncData("texSubImage2D", Tex2D, level, width, height, 1, format, type, pixels, NullNotAllowed))
-        return;
-    void* data = pixels->baseAddress();
-    Vector<uint8_t> tempData;
-    bool changeUnpackAlignment = false;
-    if (data && (m_unpackFlipY || m_unpackPremultiplyAlpha)) {
-        if (!WebGLImageConversion::extractTextureData(width, height, format, type,
-            m_unpackAlignment, m_unpackFlipY, m_unpackPremultiplyAlpha, data, tempData))
-            return;
-        data = tempData.data();
-        changeUnpackAlignment = true;
-    }
-    if (changeUnpackAlignment)
-        resetUnpackParameters();
-    contextGL()->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, data);
-    if (changeUnpackAlignment)
-        restoreUnpackParameters();
+    texImageHelperDOMArrayBufferView("texSubImage2D", target, level, 0, width, height, 0, format, type, 1, xoffset, yoffset, 0, pixels);
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
     GLenum format, GLenum type, ImageData* pixels)
 {
-    if (isContextLost())
-        return;
-    if (!pixels) {
-        synthesizeGLError(GL_INVALID_VALUE, "texSubImage2D", "no image data");
-        return;
-    }
-    if (pixels->data()->bufferBase()->isNeutered()) {
-        synthesizeGLError(GL_INVALID_VALUE, "texSubImage2D", "The source data has been neutered.");
-        return;
-    }
-    if (!validateTexture2DBinding("texSubImage2D", target))
-        return;
-    if (!validateTexFunc("texSubImage2D", TexSubImage, SourceImageData, target, level, 0,  pixels->width(), pixels->height(), 1, 0, format, type, xoffset, yoffset, 0))
-        return;
-    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;
-    }
-    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 USIGNED_BYTE and no Flip or Premultiply operation is required.
-    if (format == GL_RGBA && type == GL_UNSIGNED_BYTE && !m_unpackFlipY && !m_unpackPremultiplyAlpha) {
-        needConversion = false;
-    } else {
-        if (!WebGLImageConversion::extractImageData(pixels->data()->data(), WebGLImageConversion::DataFormat::DataFormatRGBA8, pixels->size(), format, type, m_unpackFlipY, m_unpackPremultiplyAlpha, data)) {
-            synthesizeGLError(GL_INVALID_VALUE, "texSubImage2D", "bad image data");
-            return;
-        }
-    }
-    resetUnpackParameters();
-    contextGL()->TexSubImage2D(target, level, xoffset, yoffset, pixels->width(), pixels->height(), format, type, needConversion ? data.data() : pixels->data()->data());
-    restoreUnpackParameters();
+    texImageHelperImageData("texSubImage2D", target, level, 0, 0, format, type, 1, xoffset, yoffset, 0, pixels);
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
     GLenum format, GLenum type, HTMLImageElement* image, ExceptionState& exceptionState)
 {
-    if (isContextLost())
-        return;
-    if (!validateHTMLImageElement("texSubImage2D", image, exceptionState))
-        return;
-    if (!validateTexture2DBinding("texSubImage2D", target))
-        return;
-
-    RefPtr<Image> imageForRender = image->cachedImage()->getImage();
-    if (imageForRender && imageForRender->isSVGImage())
-        imageForRender = drawImageIntoBuffer(imageForRender.release(), image->width(), image->height(), "texSubImage2D");
-
-    if (!imageForRender || !validateTexFunc("texSubImage2D", TexSubImage, SourceHTMLImageElement, target, level, 0, imageForRender->width(), imageForRender->height(), 1, 0, format, type, xoffset, yoffset, 0))
-        return;
-
-    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;
-    }
-    texSubImage2DImpl(target, level, xoffset, yoffset, format, type, imageForRender.get(), WebGLImageConversion::HtmlDomImage, m_unpackFlipY, m_unpackPremultiplyAlpha);
+    texImageHelperHTMLImageElement("texSubImage2D", target, level, 0, format, type, xoffset, yoffset, 0, image, exceptionState);
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
     GLenum format, GLenum type, HTMLCanvasElement* canvas, ExceptionState& exceptionState)
 {
-    if (isContextLost())
-        return;
-    if (!validateHTMLCanvasElement("texSubImage2D", canvas, exceptionState))
-        return;
-    WebGLTexture* texture = validateTexture2DBinding("texSubImage2D", target);
+    WebGLTexture* texture = texImageHelperHTMLCanvasElement("texSubImage2D", target, level, 0, format, type, xoffset, yoffset, 0, canvas, exceptionState);
     if (!texture)
         return;
-    if (!validateTexFunc("texSubImage2D", TexSubImage, SourceHTMLCanvasElement, target, level, 0, canvas->width(), canvas->height(), 1, 0, format, type, xoffset, yoffset, 0))
-        return;
 
     // FIXME: Implement GPU-to-GPU path for WebGL 2 and more internal formats.
     bool useReadBackPath = isWebGL2OrHigher()
         || extensionEnabled(OESTextureFloatName)
         || extensionEnabled(OESTextureHalfFloatName)
         || extensionEnabled(EXTsRGBName);
     // texImageCanvasByGPU relies on copyTextureCHROMIUM which doesn't support float/integer/sRGB internal format.
     // FIXME: relax the constrains if copyTextureCHROMIUM is upgraded to handle more formats.
     if (!canvas->renderingContext() || !canvas->renderingContext()->isAccelerated() || useReadBackPath) {
         // 2D canvas has only FrontBuffer.
         texSubImage2DImpl(target, level, xoffset, yoffset, format, type, canvas->copiedImage(FrontBuffer, PreferAcceleration).get(),
             WebGLImageConversion::HtmlDomCanvas, m_unpackFlipY, m_unpackPremultiplyAlpha);
         return;
     }
 
     texImageCanvasByGPU(TexSubImage2DByGPU, texture, target, level, GL_RGBA, type, xoffset, yoffset, 0, canvas);
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
     GLenum format, GLenum type, HTMLVideoElement* video, ExceptionState& exceptionState)
 {
-    if (isContextLost())
-        return;
-    if (!validateHTMLVideoElement("texSubImage2D", video, exceptionState))
-        return;
-    if (!validateTexture2DBinding("texSubImage2D", target))
-        return;
-    if (!validateTexFunc("texSubImage2D", TexSubImage, SourceHTMLVideoElement, target, level, 0, video->videoWidth(), video->videoHeight(), 1, 0, format, type, xoffset, yoffset, 0))
+    WebGLTexture* texture = texImageHelperHTMLVideoElement("texSubImage2D", target, level, 0, format, type, xoffset, yoffset, 0, video, exceptionState);
+    if (!texture)
         return;
 
     RefPtr<Image> image = videoFrameToImage(video);
     if (!image)
         return;
     texSubImage2DImpl(target, level, xoffset, yoffset, format, type, image.get(), WebGLImageConversion::HtmlDomVideo, m_unpackFlipY, m_unpackPremultiplyAlpha);
 }
 
 void WebGLRenderingContextBase::texSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
     GLenum format, GLenum type, ImageBitmap* bitmap, ExceptionState& exceptionState)
 {
-    if (isContextLost())
-        return;
-    if (!validateImageBitmap("texSubImage2D", bitmap, exceptionState))
-        return;
-    if (!validateTexture2DBinding("texSubImage2D", target))
-        return;
-    if (!validateTexFunc("texSubImage2D", TexSubImage, SourceImageBitmap, target, level, 0, bitmap->width(), bitmap->height(), 1, 0, format, type, 0, 0, 0))
-        return;
-    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;
-    }
-    ASSERT(bitmap->bitmapImage());
-    RefPtr<SkImage> skImage = bitmap->bitmapImage()->imageForCurrentFrame();
-    SkPixmap pixmap;
-    OwnPtr<uint8_t[]> pixelData;
-    uint8_t* pixelDataPtr = nullptr;
-    bool peekSucceed = skImage->peekPixels(&pixmap);
-    if (peekSucceed) {
-        pixelDataPtr = static_cast<uint8_t*>(pixmap.writable_addr());
-    } else if (skImage->isTextureBacked()) {
-        pixelData = bitmap->copyBitmapData(bitmap->isPremultiplied() ? PremultiplyAlpha : DontPremultiplyAlpha);
-        pixelDataPtr = pixelData.get();
-    }
-    Vector<uint8_t> data;
-    bool needConversion = true;
-    bool havePeekableRGBA = (peekSucceed && pixmap.colorType() == SkColorType::kRGBA_8888_SkColorType);
-    bool isPixelDataRBGA = (havePeekableRGBA || !peekSucceed);
-    if (isPixelDataRBGA && format == GL_RGBA && type == GL_UNSIGNED_BYTE) {
-        needConversion = false;
-    } else {
-        // In the case of ImageBitmap, we do not need to apply flipY or premultiplyAlpha.
-        bool isPixelDataBGRA = (peekSucceed && pixmap.colorType() == SkColorType::kBGRA_8888_SkColorType);
-        if ((isPixelDataBGRA && !WebGLImageConversion::extractImageData(pixelDataPtr, WebGLImageConversion::DataFormat::DataFormatBGRA8, bitmap->size(), format, type, false, false, data))
-            || (isPixelDataRBGA && !WebGLImageConversion::extractImageData(pixelDataPtr, WebGLImageConversion::DataFormat::DataFormatRGBA8, bitmap->size(), format, type, false, false, data))) {
-            synthesizeGLError(GL_INVALID_VALUE, "texSubImage2D", "bad image data");
-            return;
-        }
-    }
-    resetUnpackParameters();
-    contextGL()->TexSubImage2D(target, level, xoffset, yoffset, bitmap->width(), bitmap->height(), format, type, needConversion ? data.data() : pixelDataPtr);
-    restoreUnpackParameters();
+    texImageHelperImageBitmap("texSubImage2D", target, level, 0, format, type, xoffset, yoffset, 0, bitmap, exceptionState);
 }
 
 void WebGLRenderingContextBase::uniform1f(const WebGLUniformLocation* location, GLfloat x)
 {
     if (isContextLost() || !location)
         return;
 
     if (location->program() != m_currentProgram) {
         synthesizeGLError(GL_INVALID_OPERATION, "uniform1f", "location not for current program");
         return;
@@ skipping 1786 matching lines @@
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, 1);
 }
 
 void WebGLRenderingContextBase::restoreUnpackParameters()
 {
     if (m_unpackAlignment != 1)
         contextGL()->PixelStorei(GL_UNPACK_ALIGNMENT, m_unpackAlignment);
 }
 
 } // namespace blink