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 804 matching lines @@
 sk_sp<SkImage> WebGLRenderingContextBase::MakeImageSnapshot(
     SkImageInfo& image_info) {
   GetDrawingBuffer()->ResolveAndBindForReadAndDraw();
   gpu::gles2::GLES2Interface* gl = SharedGpuContext::Gl();
 
   SkSurfaceProps disable_lcd_props(0, kUnknown_SkPixelGeometry);
   sk_sp<SkSurface> surface = SkSurface::MakeRenderTarget(
       SharedGpuContext::Gr(), SkBudgeted::kYes, image_info, 0,
       image_info.alphaType() == kOpaque_SkAlphaType ? nullptr
                                                     : &disable_lcd_props);
-  GLuint texture_id = skia::GrBackendObjectToGrGLTextureInfo(
-                          surface->getTextureHandle(
-                              SkSurface::kDiscardWrite_TextureHandleAccess))
-                          ->fID;
+  const GrGLTextureInfo* texture_info = skia::GrBackendObjectToGrGLTextureInfo(
+      surface->getTextureHandle(SkSurface::kDiscardWrite_TextureHandleAccess));
+  GLuint texture_id = texture_info->fID;
+  GLenum texture_target = texture_info->fTarget;
 
   GetDrawingBuffer()->CopyToPlatformTexture(
-      gl, texture_id, GL_RGBA, GL_UNSIGNED_BYTE, 0, true, false, IntPoint(0, 0),
+      gl, texture_target, texture_id, true, false, IntPoint(0, 0),
       IntRect(IntPoint(0, 0), GetDrawingBuffer()->size()), kBackBuffer);
   return surface->makeImageSnapshot();
 }
 
 ImageData* WebGLRenderingContextBase::ToImageData(SnapshotReason reason) {
   ImageData* image_data = nullptr;
   // TODO(ccameron): WebGL should produce sRGB images.
   // https://crbug.com/672299
   if (GetDrawingBuffer()) {
     // 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* passed_offscreen_canvas,
     std::unique_ptr<WebGraphicsContext3DProvider> context_provider,
     const CanvasContextCreationAttributes& requested_attributes,
     unsigned version)
     : WebGLRenderingContextBase(
           nullptr,
           passed_offscreen_canvas,
@@ skipping 3898 matching lines @@
                                            GLint internalformat,
                                            GLenum format,
                                            GLenum type,
                                            HTMLImageElement* image,
                                            ExceptionState& exception_state) {
   TexImageHelperHTMLImageElement(kTexImage2D, target, level, internalformat,
                                  format, type, 0, 0, 0, image,
                                  SentinelEmptyRect(), 1, 0, exception_state);
 }
 
-bool WebGLRenderingContextBase::CanUseTexImageByGPU(
-    TexImageFunctionID function_id,
-    GLint internalformat,
-    GLenum type) {
-  if (function_id == kTexImage2D &&
-      (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
+  // 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 (function_id == kTexSubImage2D &&
-      (IsWebGL2OrHigher() || ExtensionEnabled(kOESTextureFloatName) ||
-       ExtensionEnabled(kOESTextureHalfFloatName) ||
-       ExtensionEnabled(kEXTsRGBName)))
+#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)
     return false;
+
   return true;
 }
 
 SnapshotReason WebGLRenderingContextBase::FunctionIDToSnapshotReason(
     TexImageFunctionID id) {
   switch (id) {
     case kTexImage2D:
       return kSnapshotReasonWebGLTexImage2D;
     case kTexSubImage2D:
       return kSnapshotReasonWebGLTexSubImage2D;
     case kTexImage3D:
       return kSnapshotReasonWebGLTexImage3D;
     case kTexSubImage3D:
       return kSnapshotReasonWebGLTexSubImage3D;
   }
   NOTREACHED();
   return kSnapshotReasonUnknown;
 }
 
 void WebGLRenderingContextBase::TexImageCanvasByGPU(
     TexImageFunctionID function_id,
     HTMLCanvasElement* canvas,
+    GLenum target,
     GLuint target_texture,
-    GLenum target_internalformat,
-    GLenum target_type,
-    GLint target_level,
     GLint xoffset,
     GLint yoffset,
     const IntRect& source_sub_rectangle) {
   if (!canvas->Is3D()) {
     ImageBuffer* buffer = canvas->Buffer();
-    if (buffer && !buffer->CopyToPlatformTexture(
-                      FunctionIDToSnapshotReason(function_id), ContextGL(),
-                      target_texture, target_internalformat, target_type,
-                      target_level, unpack_premultiply_alpha_, unpack_flip_y_,
-                      IntPoint(xoffset, yoffset), source_sub_rectangle)) {
+    if (buffer &&
+        !buffer->CopyToPlatformTexture(
+            FunctionIDToSnapshotReason(function_id), ContextGL(), target,
+            target_texture, unpack_premultiply_alpha_, unpack_flip_y_,
+            IntPoint(xoffset, yoffset), source_sub_rectangle)) {
       NOTREACHED();
     }
   } else {
     WebGLRenderingContextBase* gl =
         ToWebGLRenderingContextBase(canvas->RenderingContext());
     ScopedTexture2DRestorer restorer(gl);
     if (!gl->GetDrawingBuffer()->CopyToPlatformTexture(
-            ContextGL(), target_texture, target_internalformat, target_type,
-            target_level, unpack_premultiply_alpha_, !unpack_flip_y_,
-            IntPoint(xoffset, yoffset), source_sub_rectangle, kBackBuffer)) {
+            ContextGL(), target, target_texture, unpack_premultiply_alpha_,
+            !unpack_flip_y_, IntPoint(xoffset, yoffset), source_sub_rectangle,
+            kBackBuffer)) {
       NOTREACHED();
     }
   }
 }
 
 void WebGLRenderingContextBase::TexImageByGPU(
     TexImageFunctionID function_id,
     WebGLTexture* texture,
     GLenum target,
     GLint level,
-    GLint internalformat,
-    GLenum type,
     GLint xoffset,
     GLint yoffset,
     GLint zoffset,
     CanvasImageSource* image,
     const IntRect& source_sub_rectangle) {
   DCHECK(image->IsCanvasElement() || image->IsImageBitmap());
   int width = source_sub_rectangle.Width();
   int height = source_sub_rectangle.Height();
 
   ScopedTexture2DRestorer restorer(this);
 
   GLuint target_texture = texture->Object();
-  GLenum target_type = type;
-  GLenum target_internalformat = internalformat;
-  GLint target_level = level;
   bool possible_direct_copy = false;
-  if (function_id == kTexImage2D) {
-    possible_direct_copy = Extensions3DUtil::CanUseCopyTextureCHROMIUM(
-        target, internalformat, type, level);
+  if (function_id == kTexImage2D || function_id == kTexSubImage2D) {
+    possible_direct_copy = Extensions3DUtil::CanUseCopyTextureCHROMIUM(target);
   }
 
   GLint copy_x_offset = xoffset;
   GLint copy_y_offset = yoffset;
+  GLenum copy_target = target;
 
   // if direct copy is not possible, create a temporary texture and then copy
   // from canvas to temporary texture to target texture.
   if (!possible_direct_copy) {
-    target_level = 0;
-    target_internalformat = GL_RGBA;
-    target_type = GL_UNSIGNED_BYTE;
     ContextGL()->GenTextures(1, &target_texture);
     ContextGL()->BindTexture(GL_TEXTURE_2D, target_texture);
     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, target_internalformat, width,
-                            height, 0, GL_RGBA, target_type, 0);
+    ContextGL()->TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,
+                            GL_RGBA, GL_UNSIGNED_BYTE, 0);
     copy_x_offset = 0;
     copy_y_offset = 0;
+    copy_target = GL_TEXTURE_2D;
   }
 
-  if (image->IsCanvasElement()) {
-    TexImageCanvasByGPU(function_id, static_cast<HTMLCanvasElement*>(image),
-                        target_texture, target_internalformat, target_type,
-                        target_level, copy_x_offset, copy_y_offset,
-                        source_sub_rectangle);
-  } else {
-    TexImageBitmapByGPU(static_cast<ImageBitmap*>(image), target_texture,
-                        target_internalformat, target_type, target_level,
-                        !unpack_flip_y_);
+  {
+    // 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(function_id, static_cast<HTMLCanvasElement*>(image),
+                          copy_target, target_texture, copy_x_offset,
+                          copy_y_offset, source_sub_rectangle);
+    } else {
+      TexImageBitmapByGPU(static_cast<ImageBitmap*>(image), copy_target,
+                          target_texture, !unpack_flip_y_, copy_x_offset,
+                          copy_y_offset, source_sub_rectangle);
+    }
   }
 
   if (!possible_direct_copy) {
     GLuint tmp_fbo;
     ContextGL()->GenFramebuffers(1, &tmp_fbo);
     ContextGL()->BindFramebuffer(GL_FRAMEBUFFER, tmp_fbo);
     ContextGL()->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                                       GL_TEXTURE_2D, target_texture, 0);
     ContextGL()->BindTexture(texture->GetTarget(), texture->Object());
     if (function_id == kTexImage2D) {
@@ skipping 56 matching lines @@
           func_name, function_id, canvas, source_sub_rectangle, depth,
           unpack_image_height, &selecting_sub_rectangle)) {
     return;
   }
 
   if (function_id == kTexImage2D || function_id == kTexSubImage2D) {
     // 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->IsAccelerated() ||
-        !CanUseTexImageByGPU(function_id, internalformat, type)) {
+    if (!canvas->IsAccelerated() || !CanUseTexImageByGPU(type)) {
       // 2D canvas has only FrontBuffer.
       TexImageImpl(function_id, target, level, internalformat, xoffset, yoffset,
                    zoffset, format, type,
                    canvas
                        ->CopiedImage(kFrontBuffer, kPreferAcceleration,
                                      FunctionIDToSnapshotReason(function_id))
                        .Get(),
                    WebGLImageConversion::kHtmlDomCanvas, unpack_flip_y_,
                    unpack_premultiply_alpha_, source_sub_rectangle, 1, 0);
       return;
     }
 
     // The GPU-GPU copy path uses the Y-up coordinate system.
     IntRect adjusted_source_sub_rectangle = source_sub_rectangle;
     if (!unpack_flip_y_) {
       adjusted_source_sub_rectangle.SetY(canvas->height() -
                                          adjusted_source_sub_rectangle.MaxY());
     }
 
     if (function_id == kTexImage2D) {
       TexImage2DBase(target, level, internalformat,
                      source_sub_rectangle.Width(),
                      source_sub_rectangle.Height(), 0, format, type, 0);
-      TexImageByGPU(function_id, texture, target, level, internalformat, type,
-                    0, 0, 0, canvas, adjusted_source_sub_rectangle);
+      TexImageByGPU(function_id, texture, target, level, 0, 0, 0, canvas,
+                    adjusted_source_sub_rectangle);
     } else {
-      TexImageByGPU(function_id, texture, target, level, GL_RGBA, type, xoffset,
-                    yoffset, 0, canvas, adjusted_source_sub_rectangle);
+      TexImageByGPU(function_id, texture, target, level, xoffset, yoffset, 0,
+                    canvas, adjusted_source_sub_rectangle);
     }
   } 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(function_id, target, level, internalformat, xoffset, yoffset,
                  zoffset, format, type,
                  canvas
@@ skipping 63 matching lines @@
   if (!ValidateTexFunc(func_name, function_type, kSourceHTMLVideoElement,
                        target, level, internalformat, video->videoWidth(),
                        video->videoHeight(), 1, 0, format, type, xoffset,
                        yoffset, zoffset))
     return;
 
   bool source_image_rect_is_default =
       source_image_rect == SentinelEmptyRect() ||
       source_image_rect ==
           IntRect(0, 0, video->videoWidth(), video->videoHeight());
-  if (function_id == kTexImage2D && source_image_rect_is_default &&
-      depth == 1 && GL_TEXTURE_2D == target &&
-      Extensions3DUtil::CanUseCopyTextureCHROMIUM(target, internalformat, type,
-                                                  level)) {
+  const bool use_copyTextureCHROMIUM =
+      function_id == kTexImage2D && source_image_rect_is_default &&
+      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 (use_copyTextureCHROMIUM) {
     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(),
                                                  unpack_premultiply_alpha_,
                                                  unpack_flip_y_)) {
       texture->UpdateLastUploadedVideo(video->GetWebMediaPlayer());
       return;
     }
+  }
 
+  if (source_image_rect_is_default) {
+    // 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, unpack_flip_y_ || unpack_premultiply_alpha_);
+    if (video->TexImageImpl(
+            static_cast<WebMediaPlayer::TexImageFunctionID>(function_id),
+            target, ContextGL(), level,
+            ConvertTexInternalFormat(internalformat, type), format, type,
+            xoffset, yoffset, zoffset, unpack_flip_y_,
+            unpack_premultiply_alpha_ &&
+                unpack_colorspace_conversion_ == GL_NONE)) {
+      texture->UpdateLastUploadedVideo(video->GetWebMediaPlayer());
+      return;
+    }
+  }
+
+  if (use_copyTextureCHROMIUM) {
     // 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> image_buffer(
           ImageBuffer::Create(std::move(surface)));
       if (image_buffer) {
         // 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(
             image_buffer->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 (image_buffer->CopyToPlatformTexture(
-                FunctionIDToSnapshotReason(function_id), ContextGL(),
-                texture->Object(), internalformat, type, level,
-                unpack_premultiply_alpha_, unpack_flip_y_, IntPoint(0, 0),
+                FunctionIDToSnapshotReason(function_id), ContextGL(), target,
+                texture->Object(), unpack_premultiply_alpha_, unpack_flip_y_,
+                IntPoint(0, 0),
                 IntRect(0, 0, video->videoWidth(), video->videoHeight()))) {
           texture->UpdateLastUploadedVideo(video->GetWebMediaPlayer());
           return;
         }
       }
     }
   }
 
-  if (source_image_rect_is_default) {
-    // 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, unpack_flip_y_ || unpack_premultiply_alpha_);
-    if (video->TexImageImpl(
-            static_cast<WebMediaPlayer::TexImageFunctionID>(function_id),
-            target, ContextGL(), level,
-            ConvertTexInternalFormat(internalformat, type), format, type,
-            xoffset, yoffset, zoffset, unpack_flip_y_,
-            unpack_premultiply_alpha_ &&
-                unpack_colorspace_conversion_ == GL_NONE)) {
-      texture->UpdateLastUploadedVideo(video->GetWebMediaPlayer());
-      return;
-    }
-  }
-
   RefPtr<Image> image = VideoFrameToImage(video);
   if (!image)
     return;
   TexImageImpl(function_id, target, level, internalformat, xoffset, yoffset,
                zoffset, format, type, image.Get(),
                WebGLImageConversion::kHtmlDomVideo, unpack_flip_y_,
                unpack_premultiply_alpha_, source_image_rect, depth,
                unpack_image_height);
   texture->UpdateLastUploadedVideo(video->GetWebMediaPlayer());
 }
 
 void WebGLRenderingContextBase::TexImageBitmapByGPU(
     ImageBitmap* bitmap,
+    GLenum target,
     GLuint target_texture,
-    GLenum target_internalformat,
-    GLenum target_type,
-    GLint target_level,
-    bool flip_y) {
-  bitmap->BitmapImage()->CopyToTexture(GetDrawingBuffer()->ContextProvider(),
-                                       target_texture, target_internalformat,
-                                       target_type, flip_y);
+    bool flip_y,
+    GLint xoffset,
+    GLint yoffset,
+    const IntRect& source_sub_rect) {
+  bitmap->BitmapImage()->CopyToTexture(
+      GetDrawingBuffer()->ContextProvider(), target, target_texture, flip_y,
+      IntPoint(xoffset, yoffset), source_sub_rect);
 }
 
 void WebGLRenderingContextBase::texImage2D(GLenum target,
                                            GLint level,
                                            GLint internalformat,
                                            GLenum format,
                                            GLenum type,
                                            HTMLVideoElement* video,
                                            ExceptionState& exception_state) {
   TexImageHelperHTMLVideoElement(kTexImage2D, target, level, internalformat,
@@ skipping 42 matching lines @@
   GLsizei width = source_sub_rect.Width();
   GLsizei height = source_sub_rect.Height();
   if (!ValidateTexFunc(func_name, function_type, kSourceImageBitmap, 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 (function_id != kTexSubImage3D && function_id != kTexImage3D &&
-      bitmap->IsAccelerated() &&
-      CanUseTexImageByGPU(function_id, internalformat, type) &&
+      bitmap->IsAccelerated() && CanUseTexImageByGPU(type) &&
       !selecting_sub_rectangle) {
     if (function_id == kTexImage2D) {
       TexImage2DBase(target, level, internalformat, width, height, 0, format,
                      type, 0);
-      TexImageByGPU(function_id, texture, target, level, internalformat, type,
-                    0, 0, 0, bitmap, source_sub_rect);
+      TexImageByGPU(function_id, texture, target, level, 0, 0, 0, bitmap,
+                    source_sub_rect);
     } else if (function_id == kTexSubImage2D) {
-      TexImageByGPU(function_id, texture, target, level, GL_RGBA, type, xoffset,
-                    yoffset, 0, bitmap, source_sub_rect);
+      TexImageByGPU(function_id, texture, target, level, xoffset, yoffset, 0,
+                    bitmap, source_sub_rect);
     }
     return;
   }
   sk_sp<SkImage> sk_image = bitmap->BitmapImage()->ImageForCurrentFrame();
   SkPixmap pixmap;
   uint8_t* pixel_data_ptr = nullptr;
   RefPtr<Uint8Array> pixel_data;
   // 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 2396 matching lines @@
 
 void WebGLRenderingContextBase::getHTMLOrOffscreenCanvas(
     HTMLCanvasElementOrOffscreenCanvas& result) const {
   if (canvas())
     result.setHTMLCanvasElement(canvas());
   else
     result.setOffscreenCanvas(offscreenCanvas());
 }
 
 }  // namespace blink