Enable CopyTextureCHROMIUM in Blink for Tex{Sub}Image2D with more cases

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 801 matching lines @@
 sk_sp<SkImage> WebGLRenderingContextBase::makeImageSnapshot(
     SkImageInfo& imageInfo) {
   drawingBuffer()->resolveAndBindForReadAndDraw();
   gpu::gles2::GLES2Interface* gl = SharedGpuContext::gl();
 
   SkSurfaceProps disableLCDProps(0, kUnknown_SkPixelGeometry);
   sk_sp<SkSurface> surface = SkSurface::MakeRenderTarget(
       SharedGpuContext::gr(), SkBudgeted::kYes, imageInfo, 0,
       imageInfo.alphaType() == kOpaque_SkAlphaType ? nullptr
                                                    : &disableLCDProps);
-  GLuint textureId = skia::GrBackendObjectToGrGLTextureInfo(
-                         surface->getTextureHandle(
-                             SkSurface::kDiscardWrite_TextureHandleAccess))
-                         ->fID;
+  const GrGLTextureInfo* textureInfo = skia::GrBackendObjectToGrGLTextureInfo(
+      surface->getTextureHandle(SkSurface::kDiscardWrite_TextureHandleAccess));
+  GLuint textureId = textureInfo->fID;
+  GLenum textureTarget = textureInfo->fTarget;
 
   drawingBuffer()->copyToPlatformTexture(
-      gl, textureId, GL_RGBA, GL_UNSIGNED_BYTE, 0, true, false, IntPoint(0, 0),
+      gl, textureTarget, textureId, true, false, IntPoint(0, 0),
       IntRect(IntPoint(0, 0), drawingBuffer()->size()), BackBuffer);
   return surface->makeImageSnapshot();
 }
 
 ImageData* WebGLRenderingContextBase::toImageData(SnapshotReason reason) {
   ImageData* imageData = nullptr;
   // TODO(ccameron): WebGL should produce sRGB images.
   // https://crbug.com/672299
   if (drawingBuffer()) {
     // For un-premultiplied data
@@ skipping 143 matching lines @@
     GL_UNSIGNED_INT_5_9_9_9_REV,
     GL_UNSIGNED_INT_24_8,
     GL_FLOAT_32_UNSIGNED_INT_24_8_REV,
 };
 
 // ES3 enums supported by TexImageSource
 static const GLenum kSupportedTypesTexImageSourceES3[] = {
     GL_HALF_FLOAT, GL_FLOAT, GL_UNSIGNED_INT_10F_11F_11F_REV,
 };
 
-bool isUnsignedIntegerFormat(GLenum internalformat) {
-  switch (internalformat) {
-    case GL_R8UI:
-    case GL_R16UI:
-    case GL_R32UI:
-    case GL_RG8UI:
-    case GL_RG16UI:
-    case GL_RG32UI:
-    case GL_RGB8UI:
-    case GL_RGB16UI:
-    case GL_RGB32UI:
-    case GL_RGBA8UI:
-    case GL_RGB10_A2UI:
-    case GL_RGBA16UI:
-    case GL_RGBA32UI:
-      return true;
-    default:
-      return false;
-  }
-}
-
-bool isSignedIntegerFormat(GLenum internalformat) {
-  switch (internalformat) {
-    case GL_R8I:
-    case GL_R16I:
-    case GL_R32I:
-    case GL_RG8I:
-    case GL_RG16I:
-    case GL_RG32I:
-    case GL_RGB8I:
-    case GL_RGB16I:
-    case GL_RGB32I:
-    case GL_RGBA8I:
-    case GL_RGBA16I:
-    case GL_RGBA32I:
-      return true;
-    default:
-      return false;
-  }
-}
-
-bool isIntegerFormat(GLenum internalformat) {
-  return (isUnsignedIntegerFormat(internalformat) ||
-          isSignedIntegerFormat(internalformat));
-}
-
-bool isFloatType(GLenum type) {
-  switch (type) {
-    case GL_FLOAT:
-    case GL_HALF_FLOAT:
-    case GL_HALF_FLOAT_OES:
-    case GL_UNSIGNED_INT_10F_11F_11F_REV:
-      return true;
-    default:
-      return false;
-  }
-}
-
-bool isSRGBFormat(GLenum internalformat) {
-  switch (internalformat) {
-    case GL_SRGB_EXT:
-    case GL_SRGB_ALPHA_EXT:
-    case GL_SRGB8:
-    case GL_SRGB8_ALPHA8:
-      return true;
-    default:
-      return false;
-  }
-}
-
 }  // namespace
 
 WebGLRenderingContextBase::WebGLRenderingContextBase(
     OffscreenCanvas* passedOffscreenCanvas,
     std::unique_ptr<WebGraphicsContext3DProvider> contextProvider,
     const CanvasContextCreationAttributes& requestedAttributes,
     unsigned version)
     : WebGLRenderingContextBase(
           nullptr,
           passedOffscreenCanvas,
@@ skipping 3880 matching lines @@
                                            GLint internalformat,
                                            GLenum format,
                                            GLenum type,
                                            HTMLImageElement* image,
                                            ExceptionState& exceptionState) {
   texImageHelperHTMLImageElement(TexImage2D, target, level, internalformat,
                                  format, type, 0, 0, 0, image,
                                  sentinelEmptyRect(), 1, 0, exceptionState);
 }
 
-bool WebGLRenderingContextBase::canUseTexImageByGPU(
-    TexImageFunctionID functionID,
-    GLint internalformat,
-    GLenum type) {
-  if (functionID == TexImage2D &&
-      (isFloatType(type) || isIntegerFormat(internalformat) ||
-       isSRGBFormat(internalformat)))
+bool WebGLRenderingContextBase::canUseTexImageByGPU(GLenum type) {
+#if OS(MACOSX)
+  // RGB5_A1 is not color-renderable on NVIDIA Mac, see crbug.com/676209.
+  // Though, glCopyTextureCHROMIUM can handle RGB5_A1 internalformat by doing a
+  // fallback path, but it doesn't know the type info. So, we still cannot do

[Zhenyao Mo, 2017/03/31 21:12:59]

Maybe I miss something, but in command buffer side, we are able to get the type
info for texSubImage calls because we can get the TextureRef object from target.

[qiankun, 2017/04/05 08:43:16]

We can detect the type info as you said. The fallback path doesn't work in ES2
context for WebGL 1. I can enhance the fallback path to support ES2 context in
near future. Also I need to add type info into
CopyTextureCHROMIUMResourceManager::DoCopyTexture and
CopyTextureCHROMIUMResourceManager::DoCopySubTexture. I will investigate it
next.

+  // the fallback path in glCopyTextureCHROMIUM for
+  // RGBA/RGBA/UNSIGNED_SHORT_5_5_5_1 format and type combination.
+  if (type == GL_UNSIGNED_SHORT_5_5_5_1)
     return false;
-  // TODO(crbug.com/622958): Implement GPU-to-GPU path for WebGL 2 and more
-  // internal formats.
-  if (functionID == TexSubImage2D &&
-      (isWebGL2OrHigher() || extensionEnabled(OESTextureFloatName) ||
-       extensionEnabled(OESTextureHalfFloatName) ||
-       extensionEnabled(EXTsRGBName)))
+#endif
+  // OES_texture_half_float doesn't support HALF_FLOAT_OES type for
+  // CopyTexImage/CopyTexSubImage. And OES_texture_half_float doesn't require
+  // HALF_FLOAT_OES type texture to be renderable. So, HALF_FLOAT_OES type
+  // texture cannot be copied to or drawn to by glCopyTextureCHROMIUM.
+  if (type == GL_HALF_FLOAT_OES)

[Zhenyao Mo, 2017/03/31 21:12:59]

Is this the right place for this?  Because in most cases (all except ES2),
HALF_FLOAT_OES is just emulated by HALF_FLOAT.

[qiankun, 2017/04/05 08:43:15]

This is used to skip gpu path for RGBA/RGBA/HALF_FLOAT_OES texture in WebGL 1.
The dest type got at GLES2DecoderImpl::DoCopyTextureCHROMIUM and
GLES2DecoderImpl::DoCopySubTextureCHROMIUM is still HALF_FLOAT_OES. I may use a
fallback path for RGBA/RGBA/HAL_FLOAT_OES texture. I need to add type info into
CopyTextureCHROMIUMResourceManager::DoCopyTexture and
CopyTextureCHROMIUMResourceManager::DoCopySubTexture. 

     return false;
+
   return true;
 }
 
 SnapshotReason WebGLRenderingContextBase::functionIDToSnapshotReason(
     TexImageFunctionID id) {
   switch (id) {
     case TexImage2D:
       return SnapshotReasonWebGLTexImage2D;
     case TexSubImage2D:
       return SnapshotReasonWebGLTexSubImage2D;
     case TexImage3D:
       return SnapshotReasonWebGLTexImage3D;
     case TexSubImage3D:
       return SnapshotReasonWebGLTexSubImage3D;
   }
   NOTREACHED();
   return SnapshotReasonUnknown;
 }
 
 void WebGLRenderingContextBase::texImageCanvasByGPU(
     TexImageFunctionID functionID,
     HTMLCanvasElement* canvas,
+    GLenum target,
     GLuint targetTexture,
-    GLenum targetInternalformat,
-    GLenum targetType,
-    GLint targetLevel,
     GLint xoffset,
     GLint yoffset,
     const IntRect& sourceSubRectangle) {
   if (!canvas->is3D()) {
     ImageBuffer* buffer = canvas->buffer();
     if (buffer &&
         !buffer->copyToPlatformTexture(
-            functionIDToSnapshotReason(functionID), contextGL(), targetTexture,
-            targetInternalformat, targetType, targetLevel,
-            m_unpackPremultiplyAlpha, m_unpackFlipY, IntPoint(xoffset, yoffset),
-            sourceSubRectangle)) {
+            functionIDToSnapshotReason(functionID), contextGL(), target,
+            targetTexture, m_unpackPremultiplyAlpha, m_unpackFlipY,
+            IntPoint(xoffset, yoffset), sourceSubRectangle)) {
       NOTREACHED();
     }
   } else {
     WebGLRenderingContextBase* gl =
         toWebGLRenderingContextBase(canvas->renderingContext());
     ScopedTexture2DRestorer restorer(gl);
     if (!gl->drawingBuffer()->copyToPlatformTexture(
-            contextGL(), targetTexture, targetInternalformat, targetType,
-            targetLevel, m_unpackPremultiplyAlpha, !m_unpackFlipY,
-            IntPoint(xoffset, yoffset), sourceSubRectangle, BackBuffer)) {
+            contextGL(), target, targetTexture, m_unpackPremultiplyAlpha,
+            !m_unpackFlipY, IntPoint(xoffset, yoffset), sourceSubRectangle,
+            BackBuffer)) {
       NOTREACHED();
     }
   }
 }
 
 void WebGLRenderingContextBase::texImageByGPU(
     TexImageFunctionID functionID,
     WebGLTexture* texture,
     GLenum target,
     GLint level,
-    GLint internalformat,
-    GLenum type,
     GLint xoffset,
     GLint yoffset,
     GLint zoffset,
     CanvasImageSource* image,
     const IntRect& sourceSubRectangle) {
   DCHECK(image->isCanvasElement() || image->isImageBitmap());
   int width = sourceSubRectangle.width();
   int height = sourceSubRectangle.height();
 
   ScopedTexture2DRestorer restorer(this);
 
   GLuint targetTexture = texture->object();
-  GLenum targetType = type;
-  GLenum targetInternalformat = internalformat;
-  GLint targetLevel = level;
   bool possibleDirectCopy = false;
-  if (functionID == TexImage2D) {
-    possibleDirectCopy = Extensions3DUtil::canUseCopyTextureCHROMIUM(
-        target, internalformat, type, level);
+  if (functionID == TexImage2D || functionID == TexSubImage2D) {
+    possibleDirectCopy = Extensions3DUtil::canUseCopyTextureCHROMIUM(target);
   }
 
   GLint copyXOffset = xoffset;
   GLint copyYOffset = yoffset;
+  GLenum copyTarget = target;
 
   // if direct copy is not possible, create a temporary texture and then copy
   // from canvas to temporary texture to target texture.
   if (!possibleDirectCopy) {
-    targetLevel = 0;
-    targetInternalformat = GL_RGBA;
-    targetType = GL_UNSIGNED_BYTE;
     contextGL()->GenTextures(1, &targetTexture);
     contextGL()->BindTexture(GL_TEXTURE_2D, targetTexture);
     contextGL()->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
                                GL_NEAREST);
     contextGL()->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
                                GL_NEAREST);
     contextGL()->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
                                GL_CLAMP_TO_EDGE);
     contextGL()->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
                                GL_CLAMP_TO_EDGE);
-    contextGL()->TexImage2D(GL_TEXTURE_2D, 0, targetInternalformat, width,
-                            height, 0, GL_RGBA, targetType, 0);
+    contextGL()->TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,
+                            GL_RGBA, GL_UNSIGNED_BYTE, 0);
     copyXOffset = 0;
     copyYOffset = 0;
+    copyTarget = GL_TEXTURE_2D;
   }
 
-  if (image->isCanvasElement()) {
-    texImageCanvasByGPU(functionID, static_cast<HTMLCanvasElement*>(image),
-                        targetTexture, targetInternalformat, targetType,
-                        targetLevel, copyXOffset, copyYOffset,
-                        sourceSubRectangle);
-  } else {
-    texImageBitmapByGPU(static_cast<ImageBitmap*>(image), targetTexture,
-                        targetInternalformat, targetType, targetLevel,
-                        !m_unpackFlipY);
+  {
+    // glCopyTextureCHROMIUM has a DRAW_AND_READBACK path which will call
+    // texImage2D. So, reset unpack buffer parameters before that.
+    ScopedUnpackParametersResetRestore temporaryResetUnpack(this);
+    if (image->isCanvasElement()) {
+      texImageCanvasByGPU(functionID, static_cast<HTMLCanvasElement*>(image),
+                          copyTarget, targetTexture, copyXOffset, copyYOffset,
+                          sourceSubRectangle);
+    } else {
+      texImageBitmapByGPU(static_cast<ImageBitmap*>(image), copyTarget,
+                          targetTexture, !m_unpackFlipY, copyXOffset,
+                          copyYOffset, sourceSubRectangle);
+    }
   }
 
   if (!possibleDirectCopy) {
     GLuint tmpFBO;
     contextGL()->GenFramebuffers(1, &tmpFBO);
     contextGL()->BindFramebuffer(GL_FRAMEBUFFER, tmpFBO);
     contextGL()->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                                       GL_TEXTURE_2D, targetTexture, 0);
     contextGL()->BindTexture(texture->getTarget(), texture->object());
     if (functionID == TexImage2D) {
@@ skipping 56 matching lines @@
     return;
   }
 
   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)) {
+        !canUseTexImageByGPU(type)) {
       // 2D canvas has only FrontBuffer.
       texImageImpl(functionID, target, level, internalformat, xoffset, yoffset,
                    zoffset, format, type,
                    canvas
                        ->copiedImage(FrontBuffer, PreferAcceleration,
                                      functionIDToSnapshotReason(functionID))
                        .get(),
                    WebGLImageConversion::HtmlDomCanvas, m_unpackFlipY,
                    m_unpackPremultiplyAlpha, sourceSubRectangle, 1, 0);
       return;
     }
 
     // The GPU-GPU copy path uses the Y-up coordinate system.
     IntRect adjustedSourceSubRectangle = sourceSubRectangle;
     if (!m_unpackFlipY) {
       adjustedSourceSubRectangle.setY(canvas->height() -
                                       adjustedSourceSubRectangle.maxY());
     }
 
     if (functionID == TexImage2D) {
       texImage2DBase(target, level, internalformat, sourceSubRectangle.width(),
                      sourceSubRectangle.height(), 0, format, type, 0);
-      texImageByGPU(functionID, texture, target, level, internalformat, type, 0,
-                    0, 0, canvas, adjustedSourceSubRectangle);
+      texImageByGPU(functionID, texture, target, level, 0, 0, 0, canvas,
+                    adjustedSourceSubRectangle);
     } else {
-      texImageByGPU(functionID, texture, target, level, GL_RGBA, type, xoffset,
-                    yoffset, 0, canvas, adjustedSourceSubRectangle);
+      texImageByGPU(functionID, texture, target, level, xoffset, yoffset, 0,
+                    canvas, adjustedSourceSubRectangle);
     }
   } else {
     // 3D functions.
 
     // TODO(zmo): Implement GPU-to-GPU copy path (crbug.com/612542).
     // Note that code will also be needed to copy to layers of 3D
     // textures, and elements of 2D texture arrays.
     texImageImpl(
         functionID, target, level, internalformat, xoffset, yoffset, zoffset,
         format, type, canvas
@@ skipping 61 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 &&
-      GL_TEXTURE_2D == target && Extensions3DUtil::canUseCopyTextureCHROMIUM(
-                                     target, internalformat, type, level)) {
+  const bool useCopyTextureCHROMIUM =
+      functionID == TexImage2D && sourceImageRectIsDefault && depth == 1 &&
+      GL_TEXTURE_2D == target && canUseTexImageByGPU(type);
+  // Format of source video may be 16-bit format, e.g. Y16 format.
+  // glCopyTextureCHROMIUM requires the source texture to be in 8-bit format.
+  // Converting 16-bits formated source texture to 8-bits formated texture will
+  // cause precision lost. So, uploading such video texture to half float or
+  // float texture can not use GPU-GPU path.
+  if (useCopyTextureCHROMIUM) {
     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.
 
     // Note that neither
     // HTMLVideoElement::copyVideoTextureToPlatformTexture nor
     // ImageBuffer::copyToPlatformTexture allocate the destination texture
     // any more.
     texImage2DBase(target, level, internalformat, video->videoWidth(),
                    video->videoHeight(), 0, format, type, nullptr);
 
     if (video->copyVideoTextureToPlatformTexture(contextGL(), texture->object(),
                                                  m_unpackPremultiplyAlpha,
                                                  m_unpackFlipY)) {
       texture->updateLastUploadedVideo(video->webMediaPlayer());
       return;
     }
+  }
 
+  if (sourceImageRectIsDefault) {
+    // Try using optimized CPU-GPU path for some formats: e.g. Y16 and Y8. It
+    // leaves early for other formats or if frame is stored on GPU.
+    ScopedUnpackParametersResetRestore(
+        this, m_unpackFlipY || m_unpackPremultiplyAlpha);
+    if (video->texImageImpl(
+            static_cast<WebMediaPlayer::TexImageFunctionID>(functionID), target,
+            contextGL(), level, convertTexInternalFormat(internalformat, type),
+            format, type, xoffset, yoffset, zoffset, m_unpackFlipY,
+            m_unpackPremultiplyAlpha &&
+                m_unpackColorspaceConversion == GL_NONE)) {
+      texture->updateLastUploadedVideo(video->webMediaPlayer());
+      return;
+    }
+  }
+
+  if (useCopyTextureCHROMIUM) {
     // Try using an accelerated image buffer, this allows YUV conversion to be
     // done on the GPU.
     std::unique_ptr<ImageBufferSurface> surface =
         WTF::wrapUnique(new AcceleratedImageBufferSurface(
             IntSize(video->videoWidth(), video->videoHeight())));
     if (surface->isValid()) {
       std::unique_ptr<ImageBuffer> imageBuffer(
           ImageBuffer::create(std::move(surface)));
       if (imageBuffer) {
         // The video element paints an RGBA frame into our surface here. By
         // using an AcceleratedImageBufferSurface, we enable the WebMediaPlayer
         // implementation to do any necessary color space conversion on the GPU
         // (though it may still do a CPU conversion and upload the results).
         video->paintCurrentFrame(
             imageBuffer->canvas(),
             IntRect(0, 0, video->videoWidth(), video->videoHeight()), nullptr);
 
         // This is a straight GPU-GPU copy, any necessary color space conversion
         // was handled in the paintCurrentFrameInContext() call.
 
         if (imageBuffer->copyToPlatformTexture(
-                functionIDToSnapshotReason(functionID), contextGL(),
-                texture->object(), internalformat, type, level,
-                m_unpackPremultiplyAlpha, m_unpackFlipY, IntPoint(0, 0),
+                functionIDToSnapshotReason(functionID), contextGL(), target,
+                texture->object(), m_unpackPremultiplyAlpha, m_unpackFlipY,
+                IntPoint(0, 0),
                 IntRect(0, 0, video->videoWidth(), video->videoHeight()))) {
           texture->updateLastUploadedVideo(video->webMediaPlayer());
           return;
         }
       }
     }
   }
 
-  if (sourceImageRectIsDefault) {
-    // Try using optimized CPU-GPU path for some formats: e.g. Y16 and Y8. It
-    // leaves early for other formats or if frame is stored on GPU.
-    ScopedUnpackParametersResetRestore(
-        this, m_unpackFlipY || m_unpackPremultiplyAlpha);
-    if (video->texImageImpl(
-            static_cast<WebMediaPlayer::TexImageFunctionID>(functionID), target,
-            contextGL(), level, convertTexInternalFormat(internalformat, type),
-            format, type, xoffset, yoffset, zoffset, m_unpackFlipY,
-            m_unpackPremultiplyAlpha &&
-                m_unpackColorspaceConversion == GL_NONE)) {
-      texture->updateLastUploadedVideo(video->webMediaPlayer());
-      return;
-    }
-  }
-
   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, sourceImageRect, depth,
                unpackImageHeight);
   texture->updateLastUploadedVideo(video->webMediaPlayer());
 }
 
-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::texImageBitmapByGPU(
+    ImageBitmap* bitmap,
+    GLenum target,
+    GLuint targetTexture,
+    bool flipY,
+    GLint xoffset,
+    GLint yoffset,
+    const IntRect& sourceSubRectangle) {
+  bitmap->bitmapImage()->copyToTexture(
+      drawingBuffer()->contextProvider(), target, targetTexture, flipY,
+      IntPoint(xoffset, yoffset), sourceSubRectangle);
 }
 
 void WebGLRenderingContextBase::texImage2D(GLenum target,
                                            GLint level,
                                            GLint internalformat,
                                            GLenum format,
                                            GLenum type,
                                            HTMLVideoElement* video,
                                            ExceptionState& exceptionState) {
   texImageHelperHTMLVideoElement(TexImage2D, target, level, internalformat,
@@ skipping 41 matching lines @@
   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) &&
+      bitmap->isAccelerated() && canUseTexImageByGPU(type) &&
       !selectingSubRectangle) {
     if (functionID == TexImage2D) {
       texImage2DBase(target, level, internalformat, width, height, 0, format,
                      type, 0);
-      texImageByGPU(functionID, texture, target, level, internalformat, type, 0,
-                    0, 0, bitmap, sourceSubRect);
+      texImageByGPU(functionID, texture, target, level, 0, 0, 0, bitmap,
+                    sourceSubRect);
     } else if (functionID == TexSubImage2D) {
-      texImageByGPU(functionID, texture, target, level, GL_RGBA, type, xoffset,
-                    yoffset, 0, bitmap, sourceSubRect);
+      texImageByGPU(functionID, texture, target, level, xoffset, yoffset, 0,
+                    bitmap, sourceSubRect);
     }
     return;
   }
   sk_sp<SkImage> skImage = bitmap->bitmapImage()->imageForCurrentFrame();
   SkPixmap pixmap;
   uint8_t* pixelDataPtr = nullptr;
   RefPtr<Uint8Array> pixelData;
   // In the case where an ImageBitmap is not texture backed, peekPixels() always
   // succeed.  However, when it is texture backed and !canUseTexImageByGPU, we
   // do a GPU read back.
@@ skipping 2400 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(offscreenCanvas());
 }
 
 }  // namespace blink