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_
 
@@ skipping 127 matching lines @@
 
  protected:
   scoped_refptr<gfx::GLSurface> surface_;
   scoped_refptr<gfx::GLContext> context_;
   GLImageTestDelegate delegate_;
 };
 
 TYPED_TEST_CASE_P(GLImageTest);
 
 TYPED_TEST_P(GLImageTest, CreateAndDestroy) {
+  if (!this->delegate_.IsSupported())
+    return;
+
   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);
 
@@ skipping 18 matching lines @@
 REGISTER_TYPED_TEST_CASE_P(GLImageTest, CreateAndDestroy);
 
 template <typename GLImageTestDelegate>
 class GLImageZeroInitializeTest : public GLImageTest<GLImageTestDelegate> {};
 
 // This test verifies that if an uninitialized image is bound to a texture, the
 // result is zero-initialized.
 TYPED_TEST_CASE_P(GLImageZeroInitializeTest);
 
 TYPED_TEST_P(GLImageZeroInitializeTest, ZeroInitialize) {
+  // Ozone platform knows the supported format in runtime.
+  if (!this->delegate_.IsSupported())

[dshwang, 2016/04/08 13:16:31]

reveman suggested to keep static way, while ozone knows it in runtime. so let me
introduce this if statement for only ozone.

+    return;
 #if defined(OS_MACOSX)
   // This functionality is disabled on Mavericks because it breaks PDF
   // rendering. https://crbug.com/594343.
   if (base::mac::IsOSMavericks())
     return;
 #endif
 
   const gfx::Size image_size(256, 256);
 
   GLuint framebuffer =
@@ skipping 32 matching lines @@
 }
 
 REGISTER_TYPED_TEST_CASE_P(GLImageZeroInitializeTest, ZeroInitialize);
 
 template <typename GLImageTestDelegate>
 class GLImageCopyTest : public GLImageTest<GLImageTestDelegate> {};
 
 TYPED_TEST_CASE_P(GLImageCopyTest);
 
 TYPED_TEST_P(GLImageCopyTest, CopyTexImage) {
+  if (!this->delegate_.IsSupported())
+    return;
+
   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};
+  uint8_t image_color[] = {0x10, 0x20, 0x00, 0xff};
+  // glReadPixels(.., GL_RGBA, ..) for RED texture returns (R, 0x00, 0x00, 0xff)
+  if (gfx::BufferFormat::R_8 == this->delegate_.GetBufferFormat())
+    image_color[1] = 0x00;
   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);
 
   // Create a solid color blue texture of the same size as |image|.
   unsigned target = this->delegate_.GetTextureTarget();
   GLuint texture = GLTestHelper::CreateTexture(target);
   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());
   glBindTexture(target, texture);
   glTexImage2D(target, 0, GL_RGBA, image_size.width(), image_size.height(), 0,
                GL_RGBA, GL_UNSIGNED_BYTE, pixels.get());
 
   // Copy |image| to |texture|.
   bool rv = image->CopyTexImage(target);

[dshwang, 2016/04/08 13:16:31]

ozone fails this line. copy test is not relevant to ozone.

   EXPECT_TRUE(rv);
 
   // Draw |texture| to viewport.
   DrawTextureQuad(target, image_size);
 
   // Read back pixels to check expectations.
   GLTestHelper::CheckPixels(0, 0, image_size.width(), image_size.height(),
                             image_color);
 
   // Clean up.
   glDeleteTextures(1, &texture);
   glDeleteFramebuffersEXT(1, &framebuffer);
   image->Destroy(true /* have_context */);
 }
 
 // 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) {

[dshwang, 2016/04/08 13:16:31]

android can reuse this test also.

+  if (!this->delegate_.IsSupported())
+    return;
+
+  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.
+  uint8_t image_color[] = {0x10, 0x20, 0x00, 0xff};
+  // glReadPixels(.., GL_RGBA, ..) for RED texture returns (R, 0x00, 0x00, 0xff)
+  if (gfx::BufferFormat::R_8 == this->delegate_.GetBufferFormat())
+    image_color[1] = 0x00;
+
+  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);
+
+  // Bind |image| to |texture|.
+  unsigned target = this->delegate_.GetTextureTarget();
+  GLuint texture = GLTestHelper::CreateTexture(target);
+  bool rv = image->BindTexImage(target);
+  EXPECT_TRUE(rv);
+
+  // Draw |texture| to viewport.
+  DrawTextureQuad(target, image_size);
+
+  // Read back pixels to check expectations.
+  GLTestHelper::CheckPixels(0, 0, image_size.width(), image_size.height(),
+                            image_color);
+
+  // Clean up.
+  glDeleteTextures(1, &texture);
+  glDeleteFramebuffersEXT(1, &framebuffer);
+  image->Destroy(true /* have_context */);
+}
+
+// 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_