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 "base/command_line.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_switches.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";
+
+static const char* kIntTextureFragmentShaderES3 =
+  "#version 300 es\n"
+  "precision mediump float;\n"
+  "uniform mediump isampler2D u_texture;\n"
+  "in vec2 v_texCoord;\n"
+  "out vec4 fragData;\n"
+  "void main() {\n"
+  "  ivec4 color = texture(u_texture, v_texCoord);\n"
+  "  fragData = vec4(float(color[0])/255.0, float(color[1])/255.0,"
+  "float(color[2])/255.0, float(color[3])/255.0);\n"
+  "}\n";
+
 }
 
 // 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());
 }
 
+// Color-renderable to color-renderable
+TEST_P(GLCopyTextureCHROMIUMTest, R8ToR8) {
+  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_R8, 1, 1, 0, GL_RED, GL_UNSIGNED_BYTE,
+               pixels);
+
+  if (copy_type == TexImage) {
+    glCopyTextureCHROMIUM(textures_[0], textures_[1], GL_R8,
+                          GL_UNSIGNED_BYTE, false, false, false);
+  } else {
+    glBindTexture(GL_TEXTURE_2D, textures_[1]);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, 1, 1, 0, GL_RED, GL_UNSIGNED_BYTE,
+                 nullptr);
+
+    glCopySubTextureCHROMIUM(textures_[0], textures_[1], 0, 0, 0,
+                             0, 1, 1, false, false, false);
+  }
+  EXPECT_TRUE(glGetError() == GL_NO_ERROR);
+
+  // Check the FB is still bound.
+  GLint value = 0;
+  glGetIntegerv(GL_FRAMEBUFFER_BINDING, &value);
+  GLuint fb_id = value;
+  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());
+}
+
+// Color-renderable to non-color-renderable
+TEST_P(GLCopyTextureCHROMIUMTest, RGBA8IToRGB8I) {
+  CopyType copy_type = GetParam();
+  const GLsizei kWidth = 8, kHeight = 8;
+  uint8_t pixels[8 * 8 * 4];
+  for (int i = 0; i < kWidth * kHeight * 4; i += 4) {
+    pixels[i + 0] = 0;
+    pixels[i + 1] = 1;
+    pixels[i + 2] = 2;
+    pixels[i + 3] = 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, GL_RGBA8I, kWidth, kHeight, 0,
+               GL_RGBA_INTEGER, GL_BYTE, pixels);
+
+  if (copy_type == TexImage) {
+    glCopyTextureCHROMIUM(textures_[0], textures_[1], GL_RGB8I,
+                          GL_BYTE, false, false, false);
+  } else {
+    glBindTexture(GL_TEXTURE_2D, textures_[1]);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8I, kWidth, kHeight, 0,
+                 GL_RGB_INTEGER, GL_BYTE, nullptr);
+
+    glCopySubTextureCHROMIUM(textures_[0], textures_[1], 0, 0, 0,
+                             0, kWidth, kHeight, false, false, false);
+  }
+  EXPECT_TRUE(glGetError() == GL_NO_ERROR);
+
+  // Check the FB is still bound.
+  GLint value = 0;
+  glGetIntegerv(GL_FRAMEBUFFER_BINDING, &value);
+  GLuint fb_id = value;
+  EXPECT_EQ(framebuffer_id_, fb_id);
+
+  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);
+
+  glViewport(0, 0, kWidth, kHeight);
+  EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
+            glCheckFramebufferStatus(GL_FRAMEBUFFER));
+
+  GLuint program = GLTestHelper::LoadProgram(
+      kSimpleVertexShaderES3, kIntTextureFragmentShaderES3);
+  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);
+
+  // Destination texture does not contain alpha channel, sampling returns 1.
+  uint8_t expected_color[4] = {0, 1, 2, 1};
+  uint8_t result_pixels[kHeight][kWidth][4] = {{{1}}};
+  glReadPixels(0, 0, kWidth, kHeight, GL_RGBA, GL_UNSIGNED_BYTE, result_pixels);
+  for (int x = 0; x < kWidth; ++x) {
+    for (int y = 0; y < kHeight; ++y) {
+      EXPECT_EQ(expected_color[0], result_pixels[y][x][0]);
+      EXPECT_EQ(expected_color[1], result_pixels[y][x][1]);
+      EXPECT_EQ(expected_color[2], result_pixels[y][x][2]);
+    }
+  }
+  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 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};
+  // TODO(qiankun.miao@intel.com): find real unsupported formats.
+  GLint unsupported_dest_formats[] = {GL_RGBA8UI};
   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,
+                   0, GL_RGB_INTEGER, GL_UNSIGNED_BYTE,
                    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;
   }
 }
 
 TEST_F(GLCopyTextureCHROMIUMTest, InternalFormatTypeCombinationNotSupported) {
@@ skipping 305 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