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"
 
 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;
 }
 
+}  // 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]);
 
     // Some drivers (NVidia/SGX) require texture settings to be a certain way or
     // they won't report FRAMEBUFFER_COMPLETE.
     glTexParameterf(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameterf(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 
     glGenFramebuffers(1, &framebuffer_id_);
     glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_id_);
     glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target,
                            textures_[1], 0);
   }
 
   void SetUp() override {
-    gl_.Initialize(GLManager::Options());
+    GLManager::Options options;
+    options.context_type = gles2::CONTEXT_TYPE_OPENGLES3;
+    options.size = gfx::Size(64, 64);
+    gl_.Initialize(options);
 
     CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D);
   }
 
   void TearDown() override {
     glDeleteTextures(2, textures_);
     glDeleteFramebuffers(1, &framebuffer_id_);
     gl_.Destroy();
   }
 
@@ skipping 60 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());
 }
 
+// Copy with glCopyTexImage2D
+TEST_P(GLCopyTextureCHROMIUMTest, RGBA8ToRGB) {
+  CopyType copy_type = GetParam();
+  GLenum source_internal_format = GL_RGBA8;
+  GLenum source_format = GL_RGBA;
+  GLenum source_type = GL_UNSIGNED_BYTE;
+  GLenum dest_internal_format = GL_RGB;
+  GLenum dest_format = GL_RGB;
+  GLenum dest_type = GL_UNSIGNED_BYTE;
+
+  const GLsizei kWidth = 8, kHeight = 8;
+  uint8_t color[4] = {0, 1, 2, 3};
+  uint8_t pixels[8 * 8 * 4];
+  for (int i = 0; i < kWidth * kHeight * 4; i += 4) {
+    pixels[i + 0] = color[0];
+    pixels[i + 1] = color[1];
+    pixels[i + 2] = color[2];
+    pixels[i + 3] = color[3];
+  }
+
+  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, source_internal_format, kWidth, kHeight, 0,
+               source_format, source_type, pixels);
+
+  if (copy_type == TexImage) {
+    glCopyTextureCHROMIUM(textures_[0], textures_[1], dest_internal_format,
+                          dest_type, false, false, false);
+  } else {
+    glBindTexture(GL_TEXTURE_2D, textures_[1]);
+    glTexImage2D(GL_TEXTURE_2D, 0, dest_internal_format, kWidth, kHeight, 0,
+                 dest_format, dest_type, nullptr);
+
+    glCopySubTextureCHROMIUM(textures_[0], textures_[1], 0, 0, 0, 0, kWidth,
+                             kHeight, false, false, false);
+  }
+  EXPECT_TRUE(glGetError() == GL_NO_ERROR);
+
+  // 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_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);
+
+  GLTestHelper::CheckPixels(0, 0, kWidth, kHeight, 0, color, 3);
+  EXPECT_TRUE(GL_NO_ERROR == glGetError());
+}
+
 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 77 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());
 
+  struct FormatType {
+    GLenum internal_format;
+    GLenum format;
+    GLenum type;
+  };
+
   // Check unsupported format reports error.
-  GLint unsupported_dest_formats[] = {GL_ALPHA, GL_LUMINANCE,
-                                      GL_LUMINANCE_ALPHA};
-  for (size_t dest_index = 0; dest_index < arraysize(unsupported_dest_formats);
-       dest_index++) {
+  // TODO(qiankun.miao@intel.com): find real unsupported formats.
+  FormatType unsupported_format_types[] = {
+      {GL_RGBA32UI, GL_RGBA_INTEGER, GL_INT},
+  };
+  for (size_t i = 0; i < arraysize(unsupported_format_types); i++) {
     if (copy_type == TexImage) {
       glCopyTextureCHROMIUM(textures_[0], textures_[1],
-                            unsupported_dest_formats[dest_index],
-                            GL_UNSIGNED_BYTE, false, false, false);
+                            unsupported_format_types[i].internal_format,
+                            unsupported_format_types[i].type, 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,
-                   nullptr);
+      glTexImage2D(GL_TEXTURE_2D, 0,
+                   unsupported_format_types[i].internal_format, 1, 1, 0,
+                   unsupported_format_types[i].format,
+                   unsupported_format_types[i].type, nullptr);
       glCopySubTextureCHROMIUM(textures_[0], textures_[1], 0, 0,
                                0, 0, 1, 1, false, false, false);
     }
-    EXPECT_TRUE(GL_INVALID_OPERATION == glGetError())
-        << "dest_index:" << dest_index;
+    EXPECT_TRUE(GL_INVALID_OPERATION == glGetError()) << "i:" << i;
   }
 }
 
 TEST_F(GLCopyTextureCHROMIUMTest, InternalFormatTypeCombinationNotSupported) {
   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 internal_format/type combination reports error.
@@ skipping 299 matching lines @@
 }
 
 TEST_P(GLCopyTextureCHROMIUMTest, ProgramStatePreservation) {
   CopyType copy_type = GetParam();
   // unbind the one created in setup.
   glBindFramebuffer(GL_FRAMEBUFFER, 0);
   glBindTexture(GL_TEXTURE_2D, 0);
 
   GLManager gl2;
   GLManager::Options options;
+  options.context_type = gles2::CONTEXT_TYPE_OPENGLES3;
   options.size = gfx::Size(16, 16);
   options.share_group_manager = &gl_;
   gl2.Initialize(options);
   gl_.MakeCurrent();
 
   static const char* v_shader_str =
       "attribute vec4 g_Position;\n"
       "void main()\n"
       "{\n"
       "   gl_Position = g_Position;\n"
@@ skipping 314 matching lines @@
             expected_color = y < copy_region_y + 1 ? blue : white;
           }
           GLTestHelper::CheckPixels(x, y, 1, 1, 0, expected_color);
         }
       }
     }
   }
 }
 
 }  // namespace gpu