gpu, cmaa: add glApplyScreenSpaceAntialiasingCHROMIUM unittests

gpu/command_buffer/tests/gl_apply_screen_space_antialiasing_CHROMIUM_unittest.cc

+// Copyright (c) 2016 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 <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 {
+
+// A collection of tests that exercise the GL_CHROMIUM_copy_texture extension.
+class GLApplyScreenSpaceAntialiasingCHROMIUMTest : public testing::Test {
+ protected:
+  void CreateAndBindDestinationTextureAndFBO(GLenum target) {
+    glGenTextures(1, &textures_);
+    glBindTexture(target, textures_);
+
+    // 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_, 0);
+  }
+
+  void SetUp() override {
+    base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
+    GLManager::Options options;
+    gl_.InitializeWithCommandLine(options, command_line);
+    DCHECK(!gl_.workarounds().disable_framebuffer_cmaa);
+
+    available_ =
+        GLTestHelper::HasExtension("GL_CHROMIUM_screen_space_antialiasing");
+    if (!available_) {
+      LOG(INFO) << "GL_CHROMIUM_screen_space_antialiasing not supported. "
+                   "Skipping test...";
+      return;
+    }
+
+    CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                 nullptr);
+    EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
+              glCheckFramebufferStatus(GL_FRAMEBUFFER));
+
+    glClearColor(0, 1, 0, 1);
+    glClear(GL_COLOR_BUFFER_BIT);
+  }
+
+  void TearDown() override {
+    glDeleteTextures(1, &textures_);
+    glDeleteFramebuffers(1, &framebuffer_id_);
+    gl_.Destroy();
+  }
+
+  void CreateBackingForTexture(GLenum target, GLsizei width, GLsizei height) {
+    if (target == GL_TEXTURE_RECTANGLE_ARB) {
+      GLuint image_id = glCreateGpuMemoryBufferImageCHROMIUM(
+          width, height, GL_RGBA, GL_READ_WRITE_CHROMIUM);
+      glBindTexImage2DCHROMIUM(target, image_id);
+    } else {
+      glTexImage2D(target, 0, GL_RGBA, width, height, 0, GL_RGBA,
+                   GL_UNSIGNED_BYTE, nullptr);
+    }
+  }
+
+  GLenum ExtractFormatFrom(GLenum internalformat) {
+    switch (internalformat) {
+      case GL_RGBA8_OES:
+        return GL_RGBA;
+      case GL_RGB8_OES:
+        return GL_RGB;
+      case GL_BGRA8_EXT:
+        return GL_BGRA_EXT;
+      default:
+        NOTREACHED();
+        return GL_NONE;
+    }
+  }
+
+  GLManager gl_;
+  GLuint textures_;

[piman, 2016/10/19 19:10:43]

nit: texture_  (singular)

Please initialize this pod field (as well as framebuffer_id_).

[dshwang, 2016/10/20 16:21:20]

Done.

+  GLuint framebuffer_id_;
+  bool available_ = false;
+};
+
+// Test to ensure that the basic functionality of the extension works.
+TEST_F(GLApplyScreenSpaceAntialiasingCHROMIUMTest, Basic) {
+  if (!available_)
+    return;
+
+  glApplyScreenSpaceAntialiasingCHROMIUM();
+  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+
+  // 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));
+
+  uint8_t pixels[1 * 4] = {0u, 255u, 0u, 255u};
+  GLTestHelper::CheckPixels(0, 0, 1, 1, 0, pixels);
+  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+}
+
+TEST_F(GLApplyScreenSpaceAntialiasingCHROMIUMTest, DefaultFBO) {
+  if (!available_)
+    return;
+
+  glBindFramebuffer(GL_FRAMEBUFFER, 0);
+  glApplyScreenSpaceAntialiasingCHROMIUM();
+  EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError());
+}
+
+TEST_F(GLApplyScreenSpaceAntialiasingCHROMIUMTest, InternalFormat) {
+  if (!available_)
+    return;
+
+  GLint formats[] = {GL_RGB, GL_RGBA};
+  for (size_t index = 0; index < arraysize(formats); index++) {
+    glTexImage2D(GL_TEXTURE_2D, 0, formats[index], 1, 1, 0, formats[index],
+                 GL_UNSIGNED_BYTE, nullptr);
+    EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+                           textures_, 0);
+
+    glClear(GL_COLOR_BUFFER_BIT);
+
+    glApplyScreenSpaceAntialiasingCHROMIUM();
+    EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError()) << "index:"
+                                                              << index;
+
+    uint8_t pixels[1 * 4] = {0u, 255u, 0u, 255u};
+    GLTestHelper::CheckPixels(0, 0, 1, 1, 0, pixels);
+    EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+  }
+}
+
+TEST_F(GLApplyScreenSpaceAntialiasingCHROMIUMTest, InternalFormatNotSupported) {
+  if (!available_)
+    return;
+
+  // Check unsupported format reports error.
+  GLint unsupported_formats[] = {GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA};
+  for (size_t index = 0; index < arraysize(unsupported_formats); index++) {
+    glTexImage2D(GL_TEXTURE_2D, 0, unsupported_formats[index], 1, 1, 0,
+                 unsupported_formats[index], GL_UNSIGNED_BYTE, nullptr);
+    EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+                           textures_, 0);
+
+    glClear(GL_COLOR_BUFFER_BIT);
+
+    glApplyScreenSpaceAntialiasingCHROMIUM();
+    EXPECT_EQ(static_cast<GLenum>(GL_INVALID_FRAMEBUFFER_OPERATION),
+              glGetError())
+        << "index:" << index;
+  }
+}
+
+TEST_F(GLApplyScreenSpaceAntialiasingCHROMIUMTest, ImmutableTexture) {
+  if (!available_)
+    return;
+
+  if (!GLTestHelper::HasExtension("GL_EXT_texture_storage")) {
+    LOG(INFO) << "GL_EXT_texture_storage not supported. Skipping test...";
+    return;
+  }
+  GLenum internal_formats[] = {GL_RGB8_OES, GL_RGBA8_OES, GL_BGRA8_EXT};
+  for (auto internal_format : internal_formats) {
+    glDeleteTextures(1, &textures_);
+    glDeleteFramebuffers(1, &framebuffer_id_);
+    CreateAndBindDestinationTextureAndFBO(GL_TEXTURE_2D);
+    glTexStorage2DEXT(GL_TEXTURE_2D, 1, internal_format, 1, 1);
+    EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+    EXPECT_EQ(static_cast<GLenum>(GL_FRAMEBUFFER_COMPLETE),
+              glCheckFramebufferStatus(GL_FRAMEBUFFER));
+
+    glClear(GL_COLOR_BUFFER_BIT);
+
+    glApplyScreenSpaceAntialiasingCHROMIUM();
+    EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+
+    uint8_t pixels[1 * 4] = {0u, 255u, 0u, 255u};
+    GLTestHelper::CheckPixels(0, 0, 1, 1, 0, pixels);
+    EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+  }
+}
+
+// Similar to webgl conformance test 'testAntialias(true)' in
+// context-attributes-alpha-depth-stencil-antialias.html
+TEST_F(GLApplyScreenSpaceAntialiasingCHROMIUMTest, AntiAliasing) {
+  if (!available_)
+    return;
+
+  // Fill colors in the FBO as follows
+  //  +-----+
+  //  |R|R| |
+  //  +-----+
+  //  |R| | |
+  //  +-----+
+  //  | | | |
+  //  +-+-+-+
+  const int length = 3;
+  uint8_t rgba_pixels[4 * length * length] = {
+      255u, 0u, 0u, 255u, 255u, 0u, 0u, 255u, 0u, 0u, 0u, 0u,
+      255u, 0u, 0u, 255u, 0u,   0u, 0u, 0u,   0u, 0u, 0u, 0u,
+      0u,   0u, 0u, 0u,   0u,   0u, 0u, 0u,   0u, 0u, 0u, 0u,
+  };
+  glBindTexture(GL_TEXTURE_2D, textures_);
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, length, length, 0, GL_RGBA,
+               GL_UNSIGNED_BYTE, rgba_pixels);
+
+  uint8_t transparent[4] = {0u, 0u, 0u, 0u};
+  uint8_t red[4] = {255u, 0u, 0u, 255u};
+  GLTestHelper::CheckPixels(0, 0, 1, 1, 0, red);
+  GLTestHelper::CheckPixels(0, 1, 1, 1, 0, red);
+  GLTestHelper::CheckPixels(0, 2, 1, 1, 0, transparent);
+  GLTestHelper::CheckPixels(1, 0, 1, 1, 0, red);
+  GLTestHelper::CheckPixels(1, 1, 1, 1, 0, transparent);
+  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+
+  glApplyScreenSpaceAntialiasingCHROMIUM();
+  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+
+  GLTestHelper::CheckPixels(0, 0, 1, 1, 0, red);
+  GLTestHelper::CheckPixels(2, 2, 1, 1, 0, transparent);
+  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+
+  // Check if middle pixel is anti-aliased.
+  uint8_t pixels[4] = {0u};
+  glReadPixels(1, 1, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, &pixels);
+  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+  EXPECT_NE(transparent, pixels);
+  EXPECT_NE(red, pixels);
+  EXPECT_TRUE(pixels[0] > transparent[0] && pixels[0] < red[0]);
+  EXPECT_EQ(0u, pixels[1]);
+  EXPECT_EQ(0u, pixels[2]);
+  EXPECT_TRUE(pixels[3] > transparent[3] && pixels[3] < red[3]);
+}
+
+namespace {
+
+void glEnableDisable(GLint param, GLboolean value) {
+  if (value)
+    glEnable(param);
+  else
+    glDisable(param);
+}
+
+}  // unnamed namespace
+
+// Validate that some basic GL state is not touched upon execution of
+// the extension.
+TEST_F(GLApplyScreenSpaceAntialiasingCHROMIUMTest, BasicStatePreservation) {
+  if (!available_)
+    return;
+
+  GLboolean reference_settings[2] = {GL_TRUE, GL_FALSE};
+  for (int x = 0; x < 2; ++x) {
+    GLboolean setting = reference_settings[x];
+    glEnableDisable(GL_DEPTH_TEST, setting);
+    glEnableDisable(GL_SCISSOR_TEST, setting);
+    glEnableDisable(GL_STENCIL_TEST, setting);
+    glEnableDisable(GL_CULL_FACE, setting);
+    glEnableDisable(GL_BLEND, setting);
+    glColorMask(setting, setting, setting, setting);
+    glDepthMask(setting);
+
+    glActiveTexture(GL_TEXTURE1 + x);
+
+    glApplyScreenSpaceAntialiasingCHROMIUM();
+    EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+
+    EXPECT_EQ(setting, glIsEnabled(GL_DEPTH_TEST));
+    EXPECT_EQ(setting, glIsEnabled(GL_SCISSOR_TEST));
+    EXPECT_EQ(setting, glIsEnabled(GL_STENCIL_TEST));
+    EXPECT_EQ(setting, glIsEnabled(GL_CULL_FACE));
+    EXPECT_EQ(setting, glIsEnabled(GL_BLEND));
+
+    GLboolean bool_array[4] = {GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE};
+    glGetBooleanv(GL_DEPTH_WRITEMASK, bool_array);
+    EXPECT_EQ(setting, bool_array[0]);
+
+    bool_array[0] = GL_FALSE;
+    glGetBooleanv(GL_COLOR_WRITEMASK, bool_array);
+    EXPECT_EQ(setting, bool_array[0]);
+    EXPECT_EQ(setting, bool_array[1]);
+    EXPECT_EQ(setting, bool_array[2]);
+    EXPECT_EQ(setting, bool_array[3]);
+
+    GLint active_texture = 0;
+    glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture);
+    EXPECT_EQ(GL_TEXTURE1 + x, active_texture);
+  }
+
+  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+};
+
+// Verify that invocation of the extension does not modify the bound
+// texture state.
+TEST_F(GLApplyScreenSpaceAntialiasingCHROMIUMTest, TextureStatePreserved) {
+  if (!available_)
+    return;
+
+  GLuint texture_ids[2];
+  glGenTextures(2, texture_ids);
+
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, texture_ids[0]);
+
+  glActiveTexture(GL_TEXTURE1);
+  glBindTexture(GL_TEXTURE_2D, texture_ids[1]);
+
+  glApplyScreenSpaceAntialiasingCHROMIUM();
+  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+
+  GLint active_texture = 0;
+  glGetIntegerv(GL_ACTIVE_TEXTURE, &active_texture);
+  EXPECT_EQ(GL_TEXTURE1, active_texture);
+
+  GLint bound_texture = 0;
+  glGetIntegerv(GL_TEXTURE_BINDING_2D, &bound_texture);
+  EXPECT_EQ(texture_ids[1], static_cast<GLuint>(bound_texture));
+  glBindTexture(GL_TEXTURE_2D, 0);
+
+  bound_texture = 0;
+  glActiveTexture(GL_TEXTURE0);
+  glGetIntegerv(GL_TEXTURE_BINDING_2D, &bound_texture);
+  EXPECT_EQ(texture_ids[0], static_cast<GLuint>(bound_texture));
+  glBindTexture(GL_TEXTURE_2D, 0);
+
+  glDeleteTextures(2, texture_ids);
+
+  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+}
+
+TEST_F(GLApplyScreenSpaceAntialiasingCHROMIUMTest, ProgramStatePreservation) {
+  if (!available_)
+    return;
+
+  // unbind the one created in setup.
+  glBindFramebuffer(GL_FRAMEBUFFER, 0);
+  glBindTexture(GL_TEXTURE_2D, 0);
+
+  GLManager gl2;
+  GLManager::Options options;
+  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"
+      "}\n";
+  static const char* f_shader_str =
+      "precision mediump float;\n"
+      "void main()\n"
+      "{\n"
+      "  gl_FragColor = vec4(0,1,0,1);\n"
+      "}\n";
+
+  GLuint program = GLTestHelper::LoadProgram(v_shader_str, f_shader_str);
+  glUseProgram(program);
+  GLuint position_loc = glGetAttribLocation(program, "g_Position");
+  glFlush();
+
+  // Delete program from other context.
+  gl2.MakeCurrent();
+  glDeleteProgram(program);
+  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+  glFlush();
+
+  // Program should still be usable on this context.
+  gl_.MakeCurrent();
+
+  GLTestHelper::SetupUnitQuad(position_loc);
+
+  // test using program before
+  uint8_t expected[] = {
+      0, 255, 0, 255,
+  };
+  uint8_t zero[] = {
+      0, 0, 0, 0,
+  };
+  glClearColor(0, 0, 0, 0);
+  glClear(GL_COLOR_BUFFER_BIT);
+  EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, zero));
+  glDrawArrays(GL_TRIANGLES, 0, 6);
+  EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected));
+
+  // Call copyTextureCHROMIUM
+  uint8_t pixels[1 * 4] = {255u, 0u, 0u, 255u};
+  glBindTexture(GL_TEXTURE_2D, textures_);
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+               pixels);
+  glBindFramebuffer(GL_FRAMEBUFFER, framebuffer_id_);
+  glApplyScreenSpaceAntialiasingCHROMIUM();
+  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+
+  // test using program after
+  glClear(GL_COLOR_BUFFER_BIT);
+  EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, zero));
+  glDrawArrays(GL_TRIANGLES, 0, 6);
+  EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected));
+
+  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+
+  gl2.MakeCurrent();
+  gl2.Destroy();
+  gl_.MakeCurrent();
+}
+
+}  // namespace gpu