gpu: Add YCbCr 420v extension.

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"
 #include "ui/gl/test/gl_test_helper.h"
 
 namespace gfx {
 
 template <typename GLImageTestDelegate>
 class GLImageTest : public testing::Test {
@@ skipping 52 matching lines @@
 // 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 Size image_size(256, 256);
-  const uint8_t image_color[] = {0xff, 0xff, 0, 0xff};
+  // This values are picked so that RGB -> YUV on the CPU converted

[reveman, 2015/11/01 14:19:05]

nit: "These values.."

[Daniele Castagna, 2015/11/01 21:55:31]

Done.

+  // 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);
 
   // 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, BufferFormat::RGBA_8888)]);
   GLImageTestSupport::SetBufferDataToColor(
       image_size.width(), image_size.height(),
       static_cast<int>(RowSizeForBufferFormat(image_size.width(),
                                               BufferFormat::RGBA_8888, 0)),
-      BufferFormat::RGBA_8888, texture_color, pixels.get());
+      0, 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());
 
   // Copy |image| to |texture|.
   bool rv = image->CopyTexImage(GL_TEXTURE_2D);
   EXPECT_TRUE(rv);
 
@@ skipping 12 matching lines @@
     varying vec2 v_texCoord;
     void main() {
       gl_FragColor = texture2D(a_texture, v_texCoord);
     }
   );
   const char kShaderFloatPrecision[] = STRINGIZE(
     precision mediump float;
   );
   // clang-format on
 
-  GLuint vertex_shader =
-      GLTestHelper::LoadShader(GL_VERTEX_SHADER, kVertexShader);
+  GLuint vertex_shader = GLHelper::LoadShader(GL_VERTEX_SHADER, kVertexShader);
   bool is_gles = GetGLImplementation() == kGLImplementationEGLGLES2;
-  GLuint fragment_shader = GLTestHelper::LoadShader(
+  GLuint fragment_shader = GLHelper::LoadShader(
       GL_FRAGMENT_SHADER,
       base::StringPrintf("%s%s", is_gles ? kShaderFloatPrecision : "",
                          kFragmentShader)
           .c_str());
-  GLuint program = GLTestHelper::SetupProgram(vertex_shader, fragment_shader);
+  GLuint program = GLHelper::SetupProgram(vertex_shader, fragment_shader);
   EXPECT_NE(program, 0u);
   glUseProgram(program);
 
   GLint sampler_location = glGetUniformLocation(program, "a_texture");
   ASSERT_NE(sampler_location, -1);
   glUniform1i(sampler_location, 0);
 
   // clang-format off
   static GLfloat vertices[] = {
     -1.f, -1.f, 0.f, 0.f,
@@ skipping 34 matching lines @@
   image->Destroy(true);
 }
 
 // The GLImageCopyTest test case verifies that the GLImage implementation
 // handles CopyTexImage correctly.
 REGISTER_TYPED_TEST_CASE_P(GLImageCopyTest, CopyTexImage);
 
 }  // namespace gfx
 
 #endif  // UI_GL_TEST_GL_IMAGE_TEST_TEMPLATE_H_