Reland of Extend CopyTextureCHROMIUM to more ES 3.0 texture formats.

gpu/command_buffer/tests/gl_copy_texture_CHROMIUM_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES
 #endif
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
+#include <GLES3/gl3.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include "gpu/command_buffer/tests/gl_manager.h"
 #include "gpu/command_buffer/tests/gl_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gl/gl_version_info.h"
 
 namespace gpu {
 
 namespace {
+
 enum CopyType { TexImage, TexSubImage };
 const CopyType kCopyTypes[] = {
     TexImage,
     TexSubImage,
 };
+
+static const char* kSimpleVertexShaderES3 =
+    "#version 300 es\n"
+    "in vec2 a_position;\n"
+    "out vec2 v_texCoord;\n"
+    "void main() {\n"
+    "  gl_Position = vec4(a_position.x, a_position.y, 0.0, 1.0);\n"
+    "  v_texCoord = (a_position + vec2(1.0, 1.0)) * 0.5;\n"
+    "}\n";
+
+std::string GetFragmentShaderSource(GLenum format) {
+  std::string source;
+  source += std::string(
+      "#version 300 es\n"
+      "precision mediump float;\n");
+  if (gles2::GLES2Util::IsSignedIntegerFormat(format)) {
+    source += std::string("#define SamplerType isampler2D\n");
+    source += std::string("#define TextureType ivec4\n");
+    source += std::string("#define ScaleValue 255.0\n");
+  } else if (gles2::GLES2Util::IsUnsignedIntegerFormat(format)) {
+    source += std::string("#define SamplerType usampler2D\n");
+    source += std::string("#define TextureType uvec4\n");
+    source += std::string("#define ScaleValue 255.0\n");
+  } else {
+    source += std::string("#define SamplerType sampler2D\n");
+    source += std::string("#define TextureType vec4\n");
+    source += std::string("#define ScaleValue 1.0\n");
+  }
+
+  source += std::string(
+      "uniform mediump SamplerType u_texture;\n"
+      "in vec2 v_texCoord;\n"
+      "out vec4 fragData;\n"
+      "void main() {\n"
+      "  TextureType color = texture(u_texture, v_texCoord);\n"
+      "  fragData = vec4(color) / ScaleValue;\n"
+      "}\n");
+  return source;
 }
 
+void setColor(uint8_t r, uint8_t g, uint8_t b, uint8_t a, uint8_t* color) {
+  color[0] = r;
+  color[1] = g;
+  color[2] = b;
+  color[3] = a;
+}
+
+void getExpectedColor(GLenum src_internal_format,
+                      GLenum dest_internal_format,
+                      uint8_t* color,
+                      uint8_t* expected_color,
+                      uint8_t* mask) {
+  uint8_t adjust_color[4];
+  switch (src_internal_format) {
+    case GL_ALPHA:
+      setColor(0, 0, 0, color[0], adjust_color);
+      break;
+    case GL_R8:
+      setColor(color[0], 0, 0, 255, adjust_color);
+      break;
+    case GL_LUMINANCE:
+      setColor(color[0], color[0], color[0], 255, adjust_color);
+      break;
+    case GL_LUMINANCE_ALPHA:
+      setColor(color[0], color[0], color[0], color[1], adjust_color);
+      break;
+    case GL_RGB:
+    case GL_RGB8:
+    case GL_RGB_YCBCR_420V_CHROMIUM:
+    case GL_RGB_YCBCR_422_CHROMIUM:
+      setColor(color[0], color[1], color[2], 255, adjust_color);
+      break;
+    case GL_RGBA:
+    case GL_RGBA8:
+      setColor(color[0], color[1], color[2], color[3], adjust_color);
+      break;
+    case GL_BGRA_EXT:
+    case GL_BGRA8_EXT:
+      setColor(color[2], color[1], color[0], color[3], adjust_color);
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
+
+  switch (dest_internal_format) {
+    case GL_ALPHA:
+      setColor(0, 0, 0, adjust_color[3], expected_color);
+      setColor(0, 0, 0, 1, mask);
+      break;
+    case GL_R8:
+    case GL_R16F:
+    case GL_R32F:
+    case GL_R8UI:
+      setColor(adjust_color[0], 0, 0, 0, expected_color);
+      setColor(1, 0, 0, 0, mask);
+      break;
+    case GL_LUMINANCE:
+      setColor(adjust_color[0], 0, 0, 0, expected_color);
+      setColor(1, 0, 0, 0, mask);
+      break;
+    case GL_LUMINANCE_ALPHA:
+      setColor(adjust_color[0], 0, 0, adjust_color[3], expected_color);
+      setColor(1, 0, 0, 1, mask);
+      break;
+    case GL_RG8:
+    case GL_RG16F:
+    case GL_RG32F:
+    case GL_RG8UI:
+      setColor(adjust_color[0], adjust_color[1], 0, 0, expected_color);
+      setColor(1, 1, 0, 0, mask);
+      break;
+    case GL_RGB:
+    case GL_RGB8:
+    case GL_SRGB_EXT:
+    case GL_SRGB8:
+    case GL_RGB565:
+    case GL_R11F_G11F_B10F:
+    case GL_RGB9_E5:
+    case GL_RGB16F:
+    case GL_RGB32F:
+    case GL_RGB8UI:
+      setColor(adjust_color[0], adjust_color[1], adjust_color[2], 0,
+               expected_color);
+      setColor(1, 1, 1, 0, mask);
+      break;
+    case GL_RGBA:
+    case GL_RGBA8:
+    case GL_BGRA_EXT:
+    case GL_BGRA8_EXT:
+    case GL_SRGB_ALPHA_EXT:
+    case GL_SRGB8_ALPHA8:
+    case GL_RGBA4:
+    case GL_RGBA16F:
+    case GL_RGBA32F:
+    case GL_RGBA8UI:
+      setColor(adjust_color[0], adjust_color[1], adjust_color[2],
+               adjust_color[3], expected_color);
+      setColor(1, 1, 1, 1, mask);
+      break;
+    case GL_RGB5_A1:
+      setColor(adjust_color[0], adjust_color[1], adjust_color[2],
+               (adjust_color[3] >> 7) ? 0xFF : 0x0, expected_color);
+      // TODO(qiankun.miao@intel.com): On some Windows platforms, the alpha
+      // channel of expected color is the source alpha value other than 255.
+      // This should be wrong. Skip the alpha channel check and revisit this in
+      // future.
+      setColor(1, 1, 1, 0, mask);
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
+}
+
+}  // namespace
+
 // A collection of tests that exercise the GL_CHROMIUM_copy_texture extension.
 class GLCopyTextureCHROMIUMTest
     : public testing::Test,
       public ::testing::WithParamInterface<CopyType> {
  protected:
 
   void CreateAndBindDestinationTextureAndFBO(GLenum target) {
     glGenTextures(2, textures_);
     glBindTexture(target, textures_[1]);
 
@@ skipping 45 matching lines @@
         NOTREACHED();
         return GL_NONE;
     }
   }
 
   GLManager gl_;
   GLuint textures_[2];
   GLuint framebuffer_id_;
 };
 
+class GLCopyTextureCHROMIUMES3Test : public GLCopyTextureCHROMIUMTest {
+ protected:
+  void SetUp() override {
+    GLManager::Options options;
+    options.context_type = gles2::CONTEXT_TYPE_OPENGLES3;
+    options.size = gfx::Size(64, 64);
+    gl_.Initialize(options);
+
+    CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D);
+  }
+
+  // If a driver isn't capable of supporting ES3 context, creating
+  // ContextGroup will fail. Just skip the test.
+  bool ShouldSkipTest() const {
+    return (!gl_.decoder() || !gl_.decoder()->GetContextGroup());
+  }
+
+  // RGB9_E5 isn't accepted by glCopyTexImage2D if underneath context is ES.

[Zhenyao Mo, 2016/12/01 01:34:02]

This I don't understand.  If it's not accepted in ES, shouldn't we go down a
different path and still make it work?

[qiankun, 2016/12/02 16:53:46]

I am afraid we cannot make RGB9_E5 work since it's not color-renderable nor
supported by glCopyTexImage2D. glCopyTexImage2D requires component size of the
source buffer and destination buffer to match. We even cannot find a proper
intermediate format for RGB9_E5 in ES.

[Zhenyao Mo, 2016/12/03 00:39:20]

So in ValidateCopyTextureCHROMIUMInternalFormats() you actually allowed this
dest format.

I think the extension should still support this through a slow readback path,
i.e., reading back to CPU mem, and upload to the texture. This will allow us not
to worry about it in the blink side.

This can be done in a followup CL.

[qiankun, 2016/12/10 00:12:40]

Disable RGB9_E5 format for ES context before the readback path is implemented.

+  bool ShouldSkipRGB9_E5() const {
+    DCHECK(!ShouldSkipTest());
+    const gl::GLVersionInfo& gl_version_info =
+        gl_.decoder()->GetFeatureInfo()->gl_version_info();
+    return gl_version_info.is_es;
+  }
+
+  // If EXT_color_buffer_float isn't available, float format isn't supported.
+  bool ShouldSkipFloatFormat() const {
+    DCHECK(!ShouldSkipTest());
+    return !gl_.decoder()->GetFeatureInfo()->ext_color_buffer_float_available();
+  }
+
+  bool ShouldSkipBGRA() const {
+    DCHECK(!ShouldSkipTest());
+    return !gl_.decoder()
+                ->GetFeatureInfo()
+                ->feature_flags()
+                .ext_texture_format_bgra8888;
+  }
+
+  bool ShouldSkipSRGBEXT() const {
+    DCHECK(!ShouldSkipTest());
+    return !gl_.decoder()->GetFeatureInfo()->feature_flags().ext_srgb;
+  }
+};
+
 INSTANTIATE_TEST_CASE_P(CopyType,
                         GLCopyTextureCHROMIUMTest,
                         ::testing::ValuesIn(kCopyTypes));
 
+INSTANTIATE_TEST_CASE_P(CopyType,
+                        GLCopyTextureCHROMIUMES3Test,
+                        ::testing::ValuesIn(kCopyTypes));
+
 // Test to ensure that the basic functionality of the extension works.
 TEST_P(GLCopyTextureCHROMIUMTest, Basic) {
   CopyType copy_type = GetParam();
   uint8_t pixels[1 * 4] = {255u, 0u, 0u, 255u};
 
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                pixels);
 
   if (copy_type == TexImage) {
@@ skipping 16 matching lines @@
   EXPECT_EQ(framebuffer_id_, fb_id);
 
   // Check that FB is complete.
   EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
             glCheckFramebufferStatus(GL_FRAMEBUFFER));
 
   GLTestHelper::CheckPixels(0, 0, 1, 1, 0, pixels);
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 }
 
+TEST_P(GLCopyTextureCHROMIUMES3Test, FormatCombinations) {
+  if (ShouldSkipTest())
+    return;
+  CopyType copy_type = GetParam();
+
+  struct FormatType {
+    GLenum internal_format;
+    GLenum format;
+    GLenum type;
+  };
+
+  FormatType src_format_types[] = {
+      {GL_LUMINANCE, GL_LUMINANCE, GL_UNSIGNED_BYTE},
+      {GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE},
+      {GL_RGB, GL_RGB, GL_UNSIGNED_BYTE},
+      {GL_RGB8, GL_RGB, GL_UNSIGNED_BYTE},
+      {GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE},
+      {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE},
+      {GL_BGRA_EXT, GL_BGRA_EXT, GL_UNSIGNED_BYTE},
+      {GL_BGRA8_EXT, GL_BGRA_EXT, GL_UNSIGNED_BYTE},
+  };
+
+  FormatType dest_format_types[] = {
+      // TODO(qiankun.miao@intel.com): ALPHA and LUMINANCE formats have bug on
+      // GL core profile. See crbug.com/577144. Enable these formats after
+      // using workaround in gles2_cmd_copy_tex_image.cc.
+      // {GL_ALPHA, GL_ALPHA, GL_UNSIGNED_BYTE},
+      // {GL_LUMINANCE, GL_LUMINANCE, GL_UNSIGNED_BYTE},
+      // {GL_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE},
+
+      {GL_RGB, GL_RGB, GL_UNSIGNED_BYTE},
+      {GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE},
+      {GL_SRGB_EXT, GL_SRGB_EXT, GL_UNSIGNED_BYTE},
+      {GL_SRGB_ALPHA_EXT, GL_SRGB_ALPHA_EXT, GL_UNSIGNED_BYTE},
+      {GL_BGRA_EXT, GL_BGRA_EXT, GL_UNSIGNED_BYTE},
+      {GL_BGRA8_EXT, GL_BGRA_EXT, GL_UNSIGNED_BYTE},
+      {GL_R8, GL_RED, GL_UNSIGNED_BYTE},
+      {GL_R16F, GL_RED, GL_HALF_FLOAT},
+      {GL_R16F, GL_RED, GL_FLOAT},
+      {GL_R32F, GL_RED, GL_FLOAT},
+      {GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE},
+      {GL_RG8, GL_RG, GL_UNSIGNED_BYTE},
+      {GL_RG16F, GL_RG, GL_HALF_FLOAT},
+      {GL_RG16F, GL_RG, GL_FLOAT},
+      {GL_RG32F, GL_RG, GL_FLOAT},
+      {GL_RG8UI, GL_RG_INTEGER, GL_UNSIGNED_BYTE},
+      {GL_RGB8, GL_RGB, GL_UNSIGNED_BYTE},
+      {GL_SRGB8, GL_RGB, GL_UNSIGNED_BYTE},
+      {GL_RGB565, GL_RGB, GL_UNSIGNED_BYTE},
+      {GL_R11F_G11F_B10F, GL_RGB, GL_FLOAT},
+      {GL_RGB9_E5, GL_RGB, GL_HALF_FLOAT},
+      {GL_RGB9_E5, GL_RGB, GL_FLOAT},
+      {GL_RGB16F, GL_RGB, GL_HALF_FLOAT},
+      {GL_RGB16F, GL_RGB, GL_FLOAT},
+      {GL_RGB32F, GL_RGB, GL_FLOAT},
+      {GL_RGB8UI, GL_RGB_INTEGER, GL_UNSIGNED_BYTE},
+      {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE},
+      {GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE},
+      {GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_BYTE},
+      {GL_RGBA4, GL_RGBA, GL_UNSIGNED_BYTE},
+      {GL_RGBA16F, GL_RGBA, GL_HALF_FLOAT},
+      {GL_RGBA16F, GL_RGBA, GL_FLOAT},
+      {GL_RGBA32F, GL_RGBA, GL_FLOAT},
+      {GL_RGBA8UI, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE},
+  };
+
+  for (auto src_format_type : src_format_types) {
+    for (auto dest_format_type : dest_format_types) {
+      if (dest_format_type.internal_format == GL_RGB9_E5 && ShouldSkipRGB9_E5())
+        continue;
+      if ((src_format_type.internal_format == GL_BGRA_EXT ||
+           src_format_type.internal_format == GL_BGRA8_EXT ||
+           dest_format_type.internal_format == GL_BGRA_EXT ||
+           dest_format_type.internal_format == GL_BGRA8_EXT) &&
+          ShouldSkipBGRA())
+        continue;

[Zhenyao Mo, 2016/12/01 01:34:02]

Again, use {} here and below.

[qiankun, 2016/12/02 16:53:46]

Done.

+      if (gles2::GLES2Util::IsFloatFormat(dest_format_type.internal_format) &&
+          ShouldSkipFloatFormat())
+        continue;
+      if ((dest_format_type.internal_format == GL_SRGB_EXT ||
+           dest_format_type.internal_format == GL_SRGB_ALPHA_EXT) &&
+          ShouldSkipSRGBEXT())
+        continue;
+
+      const GLsizei kWidth = 8, kHeight = 8;
+      const int src_channel_count = gles2::GLES2Util::ElementsPerGroup(
+          src_format_type.format, src_format_type.type);
+      uint8_t color[4] = {1, 63, 127, 255};
+      uint8_t pixels[8 * 8 * 4];
+      for (int i = 0; i < kWidth * kHeight * src_channel_count;
+           i += src_channel_count)
+        for (int j = 0; j < src_channel_count; ++j)
+          pixels[i + j] = color[j];
+      uint8_t expected_color[4];
+      uint8_t mask[4];
+      getExpectedColor(src_format_type.internal_format,
+                       dest_format_type.internal_format, color, expected_color,
+                       mask);
+
+      glDeleteTextures(2, textures_);
+      glDeleteFramebuffers(1, &framebuffer_id_);

[Zhenyao Mo, 2016/12/01 01:34:02]

This is hard to understand.  Can we not do it in the setup, so we don't have to
do this here, instead, do it at the end of each loop?

[qiankun, 2016/12/02 16:53:46]

Done.

+      CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D);
+
+      glBindTexture(GL_TEXTURE_2D, textures_[0]);
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+      glTexImage2D(GL_TEXTURE_2D, 0, src_format_type.internal_format, kWidth,
+                   kHeight, 0, src_format_type.format, src_format_type.type,
+                   pixels);
+
+      EXPECT_TRUE(glGetError() == GL_NO_ERROR);
+      if (copy_type == TexImage) {
+        glCopyTextureCHROMIUM(textures_[0], textures_[1],
+                              dest_format_type.internal_format,
+                              dest_format_type.type, false, false, false);
+      } else {
+        glBindTexture(GL_TEXTURE_2D, textures_[1]);
+        glTexImage2D(GL_TEXTURE_2D, 0, dest_format_type.internal_format, kWidth,
+                     kHeight, 0, dest_format_type.format, dest_format_type.type,
+                     nullptr);
+
+        glCopySubTextureCHROMIUM(textures_[0], textures_[1], 0, 0, 0, 0, kWidth,
+                                 kHeight, false, false, false);
+      }
+      EXPECT_TRUE(glGetError() == GL_NO_ERROR)
+          << " src_internal_format: "
+          << gles2::GLES2Util::GetStringEnum(src_format_type.internal_format)
+          << " dest_internal_format: "
+          << gles2::GLES2Util::GetStringEnum(dest_format_type.internal_format);
+
+      // Draw destination texture to a fbo with attachment in RGBA format.
+      glBindFramebuffer(GL_FRAMEBUFFER, 0);
+      GLuint framebuffer = 0;
+      glGenFramebuffers(1, &framebuffer);
+      glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
+      GLuint texture = 0;
+      glGenTextures(1, &texture);
+      glBindTexture(GL_TEXTURE_2D, texture);
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+      glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+      CreateBackingForTexture(GL_TEXTURE_2D, kWidth, kHeight);
+      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                             GL_TEXTURE_2D, texture, 0);
+      EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
+                glCheckFramebufferStatus(GL_FRAMEBUFFER));
+      glViewport(0, 0, kWidth, kHeight);
+
+      std::string fragment_shader_source =
+          GetFragmentShaderSource(dest_format_type.internal_format);
+      GLuint program = GLTestHelper::LoadProgram(
+          kSimpleVertexShaderES3, fragment_shader_source.c_str());
+      EXPECT_NE(program, 0u);
+      GLint position_loc = glGetAttribLocation(program, "a_position");
+      GLint texture_loc = glGetUniformLocation(program, "u_texture");
+      ASSERT_NE(position_loc, -1);
+      ASSERT_NE(texture_loc, -1);
+      glUseProgram(program);
+
+      GLuint vbo = GLTestHelper::SetupUnitQuad(position_loc);
+      ASSERT_NE(vbo, 0u);
+
+      glActiveTexture(GL_TEXTURE0);
+      glBindTexture(GL_TEXTURE_2D, textures_[1]);
+
+      glDrawArrays(GL_TRIANGLES, 0, 6);
+
+      EXPECT_TRUE(GL_NO_ERROR == glGetError());
+
+      GLsizei size = kWidth * kHeight * 4;
+      std::unique_ptr<uint8_t[]> result(new uint8_t[size]);
+      glReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE,

[Zhenyao Mo, 2016/12/01 01:34:02]

This is wrong.  You can't do this with certain formats.

[qiankun, 2016/12/02 16:53:46]

The destination texture is drawn to a RGBA texture. See line482
CreateBackingForTexture().

+                   result.get());
+      uint8_t tolerance = dest_format_type.internal_format == GL_RGBA4 ? 20 : 7;
+      for (GLint yy = 0; yy < kHeight; ++yy) {
+        for (GLint xx = 0; xx < kWidth; ++xx) {
+          int offset = yy * kWidth * 4 + xx * 4;
+          for (int jj = 0; jj < 4; ++jj) {
+            uint8_t actual = result[offset + jj];
+            uint8_t expected = expected_color[jj];
+            int diff = actual - expected;
+            diff = diff < 0 ? -diff : diff;
+            if (mask[jj] && diff > tolerance) {
+              EXPECT_EQ(expected, actual)
+                  << " at " << xx << ", " << yy << " channel " << jj
+                  << " src_internal_format: "
+                  << gles2::GLES2Util::GetStringEnum(
+                         src_format_type.internal_format)
+                  << " dest_internal_format: "
+                  << gles2::GLES2Util::GetStringEnum(
+                         dest_format_type.internal_format);
+            }
+          }
+        }
+      }
+
+      glDeleteTextures(1, &texture);
+      glDeleteFramebuffers(1, &framebuffer);
+    }
+  }
+}
+
 TEST_P(GLCopyTextureCHROMIUMTest, ImmutableTexture) {
   if (!GLTestHelper::HasExtension("GL_EXT_texture_storage")) {
     LOG(INFO) << "GL_EXT_texture_storage not supported. Skipping test...";
     return;
   }
   CopyType copy_type = GetParam();
   GLenum src_internal_formats[] = {GL_RGB8_OES, GL_RGBA8_OES, GL_BGRA8_EXT};
   GLenum dest_internal_formats[] = {GL_RGB8_OES, GL_RGBA8_OES, GL_BGRA8_EXT};
 
   uint8_t pixels[1 * 4] = {255u, 0u, 255u, 255u};
@@ skipping 78 matching lines @@
 }
 
 TEST_P(GLCopyTextureCHROMIUMTest, InternalFormatNotSupported) {
   CopyType copy_type = GetParam();
   glBindTexture(GL_TEXTURE_2D, textures_[0]);
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                nullptr);
   EXPECT_TRUE(GL_NO_ERROR == glGetError());
 
   // Check unsupported format reports error.
-  GLint unsupported_dest_formats[] = {GL_ALPHA, GL_LUMINANCE,
-                                      GL_LUMINANCE_ALPHA};
+  GLint unsupported_dest_formats[] = {GL_RED, GL_RG};
   for (size_t dest_index = 0; dest_index < arraysize(unsupported_dest_formats);
        dest_index++) {
     if (copy_type == TexImage) {
       glCopyTextureCHROMIUM(textures_[0], textures_[1],
                             unsupported_dest_formats[dest_index],
                             GL_UNSIGNED_BYTE, false, false, false);
     } else {
       glBindTexture(GL_TEXTURE_2D, textures_[1]);
       glTexImage2D(GL_TEXTURE_2D, 0, unsupported_dest_formats[dest_index], 1, 1,
                    0, unsupported_dest_formats[dest_index], GL_UNSIGNED_BYTE,
@@ skipping 649 matching lines @@
             expected_color = y < copy_region_y + 1 ? blue : white;
           }
           GLTestHelper::CheckPixels(x, y, 1, 1, 0, expected_color);
         }
       }
     }
   }
 }
 
 }  // namespace gpu