blob: a9fa0462037a6ba3e236719be39da530ffb1c406 [file] [log] [blame]
// 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 <stdint.h>
#include <memory>
#include "base/optional.h"
#include "base/strings/stringize_macros.h"
#include "base/strings/stringprintf.h"
#include "build/build_config.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_surface.h"
#include "ui/gl/gl_version_info.h"
#include "ui/gl/init/gl_factory.h"
#include "ui/gl/test/gl_image_test_support.h"
#include "ui/gl/test/gl_test_helper.h"
#if defined(OS_MACOSX)
#include "base/mac/mac_util.h"
#endif
namespace gl {
namespace internal {
void DrawTextureQuad(GLenum target, const gfx::Size& size);
}
class GLImageTestDelegateBase {
public:
virtual ~GLImageTestDelegateBase() {}
virtual base::Optional<GLImplementation> GetPreferedGLImplementation() const;
virtual bool SkipTest() const;
};
template <typename GLImageTestDelegate>
class GLImageTest : public testing::Test {
protected:
// Overridden from testing::Test:
void SetUp() override {
auto prefered_impl = delegate_.GetPreferedGLImplementation();
GLImageTestSupport::InitializeGL(prefered_impl);
surface_ = gl::init::CreateOffscreenGLSurface(gfx::Size());
context_ =
gl::init::CreateGLContext(nullptr, surface_.get(), GLContextAttribs());
context_->MakeCurrent(surface_.get());
}
void TearDown() override {
context_->ReleaseCurrent(surface_.get());
context_ = nullptr;
surface_ = nullptr;
GLImageTestSupport::CleanupGL();
}
protected:
scoped_refptr<GLSurface> surface_;
scoped_refptr<GLContext> context_;
GLImageTestDelegate delegate_;
};
TYPED_TEST_CASE_P(GLImageTest);
TYPED_TEST_P(GLImageTest, Create) {
if (this->delegate_.SkipTest())
return;
// NOTE: On some drm devices (mediatek) the mininum width/height to add an fb
// for a bo must be 64.
const gfx::Size small_image_size(64, 64);
const gfx::Size large_image_size(512, 512);
const uint8_t* image_color = this->delegate_.GetImageColor();
// Create a small solid color green image of preferred format. This must
// succeed in order for a GLImage to be conformant.
scoped_refptr<GLImage> small_image =
this->delegate_.CreateSolidColorImage(small_image_size, image_color);
ASSERT_TRUE(small_image);
// Create a large solid color green image of preferred format. This must
// succeed in order for a GLImage to be conformant.
scoped_refptr<GLImage> large_image =
this->delegate_.CreateSolidColorImage(large_image_size, image_color);
ASSERT_TRUE(large_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());
}
// The GLImageTest test case verifies the behaviour that is expected from a
// GLImage in order to be conformant.
REGISTER_TYPED_TEST_CASE_P(GLImageTest, Create);
template <typename GLImageTestDelegate>
class GLImageOddSizeTest : public GLImageTest<GLImageTestDelegate> {};
// This test verifies that odd-sized GLImages can be created and destroyed.
TYPED_TEST_CASE_P(GLImageOddSizeTest);
TYPED_TEST_P(GLImageOddSizeTest, Create) {
if (this->delegate_.SkipTest())
return;
const gfx::Size odd_image_size(17, 53);
const uint8_t* image_color = this->delegate_.GetImageColor();
// Create an odd-sized solid color green image of preferred format. This must
// succeed in order for a GLImage to be conformant.
scoped_refptr<GLImage> odd_image =
this->delegate_.CreateSolidColorImage(odd_image_size, image_color);
ASSERT_TRUE(odd_image);
// Verify that image size is correct.
EXPECT_EQ(odd_image->GetSize().ToString(), odd_image_size.ToString());
}
// The GLImageTest test case verifies the behaviour that is expected from a
// GLImage in order to be conformant.
REGISTER_TYPED_TEST_CASE_P(GLImageOddSizeTest, Create);
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) {
if (this->delegate_.SkipTest())
return;
#if defined(OS_MACOSX)
// This functionality is disabled on Yosemite because it is suspected of
// causing performance regressions on old hardware. https://crbug.com/606850.
if (base::mac::IsOS10_10())
return;
#endif
const gfx::Size image_size(256, 256);
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 an uninitialized image of preferred format.
scoped_refptr<GLImage> image = this->delegate_.CreateImage(image_size);
// Create a texture that |image| will be bound to.
GLenum target = this->delegate_.GetTextureTarget();
GLuint texture = GLTestHelper::CreateTexture(target);
glBindTexture(target, texture);
// Bind |image| to |texture|.
bool rv = image->BindTexImage(target);
EXPECT_TRUE(rv);
// Draw |texture| to viewport.
internal::DrawTextureQuad(target, image_size);
// Release |image| from |texture|.
image->ReleaseTexImage(target);
// Read back pixels to check expectations.
const uint8_t zero_color[] = {0, 0, 0, 0};
GLTestHelper::CheckPixels(0, 0, image_size.width(), image_size.height(),
zero_color);
// Clean up.
glDeleteTextures(1, &texture);
glDeleteFramebuffersEXT(1, &framebuffer);
}
REGISTER_TYPED_TEST_CASE_P(GLImageZeroInitializeTest, ZeroInitialize);
template <typename GLImageTestDelegate>
class GLImageBindTest : public GLImageTest<GLImageTestDelegate> {};
TYPED_TEST_CASE_P(GLImageBindTest);
TYPED_TEST_P(GLImageBindTest, BindTexImage) {
if (this->delegate_.SkipTest())
return;
const gfx::Size image_size(256, 256);
const uint8_t* image_color = this->delegate_.GetImageColor();
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<GLImage> image =
this->delegate_.CreateSolidColorImage(image_size, image_color);
ASSERT_TRUE(image);
// Initialize a blue texture of the same size as |image|.
unsigned target = this->delegate_.GetTextureTarget();
GLuint texture = GLTestHelper::CreateTexture(target);
glBindTexture(target, texture);
// Bind |image| to |texture|.
bool rv = image->BindTexImage(target);
EXPECT_TRUE(rv);
glClearColor(0.0f, 0.0f, 1.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
// Draw |texture| to viewport.
internal::DrawTextureQuad(target, image_size);
// Read back pixels to check expectations.
GLTestHelper::CheckPixelsWithError(
0, 0, image_size.width(), image_size.height(),
this->delegate_.GetAdmissibleError(), image_color);
// Clean up.
glDeleteTextures(1, &texture);
glDeleteFramebuffersEXT(1, &framebuffer);
}
REGISTER_TYPED_TEST_CASE_P(GLImageBindTest, BindTexImage);
template <typename GLImageTestDelegate>
class GLImageCopyTest : public GLImageTest<GLImageTestDelegate> {};
TYPED_TEST_CASE_P(GLImageCopyTest);
TYPED_TEST_P(GLImageCopyTest, CopyTexImage) {
if (this->delegate_.SkipTest())
return;
const gfx::Size image_size(256, 256);
const uint8_t* image_color = this->delegate_.GetImageColor();
const uint8_t texture_color[] = {0, 0, 0xff, 0xff};
GLuint vao = 0;
if (GLContext::GetCurrent()->GetVersionInfo()->IsAtLeastGL(3, 3)) {
// To avoid glGetVertexAttribiv(0, ...) failing.
glGenVertexArraysOES(1, &vao);
glBindVertexArrayOES(vao);
}
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<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);
std::unique_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);
EXPECT_TRUE(rv);
// Draw |texture| to viewport.
internal::DrawTextureQuad(target, image_size);
// Read back pixels to check expectations.
GLTestHelper::CheckPixelsWithError(
0, 0, image_size.width(), image_size.height(),
this->delegate_.GetAdmissibleError(), image_color);
// Clean up.
glDeleteTextures(1, &texture);
glDeleteFramebuffersEXT(1, &framebuffer);
if (vao) {
glDeleteVertexArraysOES(1, &vao);
}
}
// The GLImageCopyTest test case verifies that the GLImage implementation
// handles CopyTexImage correctly.
REGISTER_TYPED_TEST_CASE_P(GLImageCopyTest, CopyTexImage);
} // namespace gl
#endif // UI_GL_TEST_GL_IMAGE_TEST_TEMPLATE_H_