gl, ozone: enable GLImageBindTest unittests

ui/gl/test/gl_image_test_template.h

 // Copyright 2015 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.
 
 // This file defines tests that implementations of GLImage should pass in order
 // to be conformant.
 
 #ifndef UI_GL_TEST_GL_IMAGE_TEST_TEMPLATE_H_
 #define UI_GL_TEST_GL_IMAGE_TEST_TEMPLATE_H_
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/strings/stringize_macros.h"
-#include "base/strings/stringprintf.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gfx/buffer_types.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_helper.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/test/gl_image_test_support.h"
@@ skipping 25 matching lines @@
   GLImageTestDelegate delegate_;
 };
 
 TYPED_TEST_CASE_P(GLImageTest);
 
 TYPED_TEST_P(GLImageTest, CreateAndDestroy) {
   const gfx::Size small_image_size(4, 4);
   const gfx::Size large_image_size(512, 512);
   const uint8_t image_color[] = {0, 0xff, 0, 0xff};
 
-  // Create a small solid color green image of preferred format. This must
-  // succeed in order for a GLImage to be conformant.
-  scoped_refptr<gl::GLImage> small_image =
-      this->delegate_.CreateSolidColorImage(small_image_size, image_color);
-  ASSERT_TRUE(small_image);
+  for (auto format : gfx::GetBufferFormatsForTesting()) {
+    if (!TypeParam::IsSupported(format)) {

[reveman, 2015/12/18 21:51:04]

can we keep requiring each implementation to decide what formats to instantiate
the test for instead of this? I think that's much cleaner than a conditional
like this. 

[dshwang, 2016/01/11 15:31:10]

I agree, but we cannot.
each ozone backend supports different format list, so ozone knows it in runtime.
I actually copy this pattern from gpu_memory_buffer_factory_test_template.h
https://code.google.com/p/chromium/codesearch#chromium/src/content/test/gpu_m...

See how ozone check it in runtime.
static bool IsSupported(gfx::BufferFormat format) {
  return ui::ClientNativePixmapFactory::GetInstance()
      ->IsConfigurationSupported(format, usage);
}

+      continue;
+    }
 
-  // Create a large solid color green image of preferred format. This must
-  // succeed in order for a GLImage to be conformant.
-  scoped_refptr<gl::GLImage> large_image =
-      this->delegate_.CreateSolidColorImage(large_image_size, image_color);
-  ASSERT_TRUE(large_image);
+    // Create a small solid color green image of preferred format. This must
+    // succeed in order for a GLImage to be conformant.
+    scoped_refptr<gl::GLImage> small_image =
+        this->delegate_.CreateSolidColorImage(small_image_size, format,
+                                              image_color);
+    ASSERT_TRUE(small_image);
 
-  // Verify that image size is correct.
-  EXPECT_EQ(small_image->GetSize().ToString(), small_image_size.ToString());
-  EXPECT_EQ(large_image->GetSize().ToString(), large_image_size.ToString());
+    // Create a large solid color green image of preferred format. This must
+    // succeed in order for a GLImage to be conformant.
+    scoped_refptr<gl::GLImage> large_image =
+        this->delegate_.CreateSolidColorImage(large_image_size, format,
+                                              image_color);
+    ASSERT_TRUE(large_image);
 
-  // Verify that destruction of images work correctly both when we have a
-  // context and when we don't.
-  small_image->Destroy(true /* have_context */);
-  large_image->Destroy(false /* have_context */);
+    // Verify that image size is correct.
+    EXPECT_EQ(small_image->GetSize().ToString(), small_image_size.ToString());
+    EXPECT_EQ(large_image->GetSize().ToString(), large_image_size.ToString());
+
+    // Verify that destruction of images work correctly both when we have a
+    // context and when we don't.
+    small_image->Destroy(true /* have_context */);
+    large_image->Destroy(false /* have_context */);
+  }
 }
 
 // The GLImageTest test case verifies the behaviour that is expected from a
 // GLImage in order to be conformant.
 REGISTER_TYPED_TEST_CASE_P(GLImageTest, CreateAndDestroy);
 
 template <typename GLImageTestDelegate>
 class GLImageCopyTest : public GLImageTest<GLImageTestDelegate> {};
 
 TYPED_TEST_CASE_P(GLImageCopyTest);
 
 TYPED_TEST_P(GLImageCopyTest, CopyTexImage) {
   const gfx::Size image_size(256, 256);
   // These values are picked so that RGB -> YUV on the CPU converted
   // back to RGB on the GPU produces the original RGB values without
   // any error.
   const uint8_t image_color[] = {0x10, 0x20, 0, 0xff};
   const uint8_t texture_color[] = {0, 0, 0xff, 0xff};
 
   GLuint framebuffer =
       GLTestHelper::SetupFramebuffer(image_size.width(), image_size.height());
   ASSERT_TRUE(framebuffer);
   glBindFramebufferEXT(GL_FRAMEBUFFER, framebuffer);
   glViewport(0, 0, image_size.width(), image_size.height());
 
-  // Create a solid color green image of preferred format. This must succeed
-  // in order for a GLImage to be conformant.
-  scoped_refptr<gl::GLImage> image =
-      this->delegate_.CreateSolidColorImage(image_size, image_color);
-  ASSERT_TRUE(image);
+  GLuint program = GLImageTestSupport::CreateSingleTextureProgram();
+  GLuint vertex_buffer = gfx::GLHelper::SetupQuadVertexBuffer();
 
-  // Create a solid color blue texture of the same size as |image|.
-  GLuint texture = GLTestHelper::CreateTexture(GL_TEXTURE_2D);
-  scoped_ptr<uint8_t[]> pixels(new uint8_t[BufferSizeForBufferFormat(
-      image_size, gfx::BufferFormat::RGBA_8888)]);
-  GLImageTestSupport::SetBufferDataToColor(
-      image_size.width(), image_size.height(),
-      static_cast<int>(RowSizeForBufferFormat(image_size.width(),
-                                              gfx::BufferFormat::RGBA_8888, 0)),
-      0, gfx::BufferFormat::RGBA_8888, texture_color, pixels.get());
-  // Note: This test assume that |image| can be used with GL_TEXTURE_2D but
-  // that might not be the case for some GLImage implementations.
-  glBindTexture(GL_TEXTURE_2D, texture);
-  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image_size.width(),
-               image_size.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels.get());
+  for (auto format : gfx::GetBufferFormatsForTesting()) {
+    if (!TypeParam::IsSupported(format)) {
+      continue;
+    }
 
-  // Copy |image| to |texture|.
-  bool rv = image->CopyTexImage(GL_TEXTURE_2D);
-  EXPECT_TRUE(rv);
+    // Create a solid color green image of preferred format. This must succeed
+    // in order for a GLImage to be conformant.
+    scoped_refptr<gl::GLImage> image =
+        this->delegate_.CreateSolidColorImage(image_size, format, image_color);
+    ASSERT_TRUE(image);
 
-  // clang-format off
-  const char kVertexShader[] = STRINGIZE(
-    attribute vec2 a_position;
-    varying vec2 v_texCoord;
-    void main() {
-      gl_Position = vec4(a_position.x, a_position.y, 0.0, 1.0);
-      v_texCoord = (a_position + vec2(1.0, 1.0)) * 0.5;
-    }
-  );
-  const char kFragmentShader[] = STRINGIZE(
-    uniform sampler2D a_texture;
-    varying vec2 v_texCoord;
-    void main() {
-      gl_FragColor = texture2D(a_texture, v_texCoord);
-    }
-  );
-  const char kShaderFloatPrecision[] = STRINGIZE(
-    precision mediump float;
-  );
-  // clang-format on
+    // Create a solid color blue texture of the same size as |image|.
+    GLuint texture = GLTestHelper::CreateTexture(GL_TEXTURE_2D);
+    scoped_ptr<uint8_t[]> pixels(new uint8_t[BufferSizeForBufferFormat(
+        image_size, gfx::BufferFormat::RGBA_8888)]);
+    GLImageTestSupport::SetBufferDataToColor(
+        image_size.width(), image_size.height(),
+        static_cast<int>(RowSizeForBufferFormat(
+            image_size.width(), gfx::BufferFormat::RGBA_8888, 0)),
+        0, gfx::BufferFormat::RGBA_8888, texture_color, pixels.get());
+    // Note: This test assume that |image| can be used with GL_TEXTURE_2D but
+    // that might not be the case for some GLImage implementations.
+    glBindTexture(GL_TEXTURE_2D, texture);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image_size.width(),
+                 image_size.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                 pixels.get());
 
-  GLuint vertex_shader =
-      gfx::GLHelper::LoadShader(GL_VERTEX_SHADER, kVertexShader);
-  bool is_gles = gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2;
-  GLuint fragment_shader = gfx::GLHelper::LoadShader(
-      GL_FRAGMENT_SHADER,
-      base::StringPrintf("%s%s", is_gles ? kShaderFloatPrecision : "",
-                         kFragmentShader)
-          .c_str());
-  GLuint program = gfx::GLHelper::SetupProgram(vertex_shader, fragment_shader);
-  EXPECT_NE(program, 0u);
-  glUseProgram(program);
+    // Copy |image| to |texture|.
+    bool rv = image->CopyTexImage(GL_TEXTURE_2D);
+    EXPECT_TRUE(rv);
 
-  GLint sampler_location = glGetUniformLocation(program, "a_texture");
-  ASSERT_NE(sampler_location, -1);
-  glUniform1i(sampler_location, 0);
+    // Draw |texture| to viewport and read back pixels to check expectations.
+    gfx::GLHelper::DrawQuad(vertex_buffer);
 
-  GLuint vertex_buffer = gfx::GLHelper::SetupQuadVertexBuffer();
-  // Draw |texture| to viewport and read back pixels to check expectations.
-  gfx::GLHelper::DrawQuad(vertex_buffer);
+    GLTestHelper::CheckPixels(0, 0, image_size.width(), image_size.height(),
+                              image_color);
 
-  GLTestHelper::CheckPixels(0, 0, image_size.width(), image_size.height(),
-                            image_color);
-
-  // Clean up.
+    // Clean up.
+    glDeleteTextures(1, &texture);
+    image->Destroy(true);
+  }
   glDeleteProgram(program);
-  glDeleteShader(vertex_shader);
-  glDeleteShader(fragment_shader);
   glDeleteBuffersARB(1, &vertex_buffer);
-  glDeleteTextures(1, &texture);
   glDeleteFramebuffersEXT(1, &framebuffer);
-  image->Destroy(true);
 }
 
 // The GLImageCopyTest test case verifies that the GLImage implementation
 // handles CopyTexImage correctly.
 REGISTER_TYPED_TEST_CASE_P(GLImageCopyTest, CopyTexImage);
 
+template <typename GLImageTestDelegate>
+class GLImageBindTest : public GLImageTest<GLImageTestDelegate> {};
+
+TYPED_TEST_CASE_P(GLImageBindTest);
+
+TYPED_TEST_P(GLImageBindTest, BindTexImage) {
+  const gfx::Size image_size(256, 256);
+  const uint8_t image_color[] = {0x10, 0x20, 0, 0xff};
+
+  GLuint framebuffer =
+      GLTestHelper::SetupFramebuffer(image_size.width(), image_size.height());
+  ASSERT_TRUE(framebuffer);
+  glBindFramebufferEXT(GL_FRAMEBUFFER, framebuffer);
+  glViewport(0, 0, image_size.width(), image_size.height());
+
+  GLuint program = GLImageTestSupport::CreateSingleTextureProgram();
+  GLuint vertex_buffer = gfx::GLHelper::SetupQuadVertexBuffer();
+
+  for (auto format : gfx::GetBufferFormatsForTesting()) {
+    if (!TypeParam::IsSupported(format)) {
+      continue;
+    }
+
+    // Create a solid color green image of preferred format. This must succeed
+    // in order for a GLImage to be conformant.
+    scoped_refptr<gl::GLImage> image =
+        this->delegate_.CreateSolidColorImage(image_size, format, image_color);
+    ASSERT_TRUE(image);
+
+    GLuint texture = GLTestHelper::CreateTexture(GL_TEXTURE_2D);
+
+    // Bind |image| to |texture|.
+    bool rv = image->BindTexImage(GL_TEXTURE_2D);
+    EXPECT_TRUE(rv);
+
+    // Draw |texture| to viewport and read back pixels to check expectations.
+    gfx::GLHelper::DrawQuad(vertex_buffer);
+
+    GLTestHelper::CheckPixels(0, 0, image_size.width(), image_size.height(),
+                              image_color);
+
+    // Clean up.
+    glDeleteTextures(1, &texture);
+    image->Destroy(true);
+  }
+  glDeleteProgram(program);
+  glDeleteBuffersARB(1, &vertex_buffer);
+  glDeleteFramebuffersEXT(1, &framebuffer);
+}
+
+// The GLImageBindTest test case verifies that the GLImage implementation
+// handles BindTexImage correctly.
+REGISTER_TYPED_TEST_CASE_P(GLImageBindTest, BindTexImage);
+
 }  // namespace gl
 
 #endif  // UI_GL_TEST_GL_IMAGE_TEST_TEMPLATE_H_