CMAA: Avoid DCHECK failure for unsupported internalformats

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 <GLES3/gl3.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"
 
@@ skipping 12 matching lines @@
     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);
-
+  void CheckStatus() {
     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,
@@ skipping 11 matching lines @@
     // For example, linux NVidia fails with this log.
     // ApplyFramebufferAttachmentCMAAINTEL: shader compilation failed:
     // GL_FRAGMENT_SHADER shader compilation failed: 0(98) : error C3013:
     // input/output layout qualifiers supported above GL version 130
     available_ = false;
     LOG(ERROR) << "GL_CHROMIUM_screen_space_antialiasing maybe not supported "
                   "in non-Intel GPU.";
     DeleteResources();
   }
 
+  void SetUp() override {
+    base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
+    GLManager::Options options;
+    gl_.InitializeWithCommandLine(options, command_line);
+    CheckStatus();
+  }
+
   void TearDown() override {
     if (available_)
       DeleteResources();
     gl_.Destroy();
   }
 
   void DeleteResources() {
     glDeleteTextures(1, &textures_);
     glDeleteFramebuffers(1, &framebuffer_id_);
   }
 
   GLManager gl_;
   GLuint textures_ = 0;
   GLuint framebuffer_id_ = 0;
   bool available_ = false;
 };
 
+class GLApplyScreenSpaceAntialiasingCHROMIUMES3Test
+    : public GLApplyScreenSpaceAntialiasingCHROMIUMTest {
+ protected:
+  void SetUp() override {
+    base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
+    GLManager::Options options;
+    options.context_type = gles2::CONTEXT_TYPE_OPENGLES3;
+    gl_.InitializeWithCommandLine(options, command_line);
+    CheckStatus();
+  }
+};
+
 // TODO(dongseong.hwang): This test fails on the Nexus 9 GPU fyi bot.
 // crbug.com/659638
 #if defined(OS_ANDROID)
 #define MAYBE_Basic DISABLED_Basic
 #else
 #define MAYBE_Basic Basic
 #endif
 // Test to ensure that the basic functionality of the extension works.
 TEST_F(GLApplyScreenSpaceAntialiasingCHROMIUMTest, MAYBE_Basic) {
   if (!available_)
@@ skipping 50 matching lines @@
     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, nullptr);
     EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
   }
 }
 
+struct FormatType {
+  GLenum internal_format;
+  GLenum format;
+  GLenum type;
+};
+
+TEST_F(GLApplyScreenSpaceAntialiasingCHROMIUMES3Test, InternalFormat) {
+  if (!available_)
+    return;
+
+  FormatType format_type = {GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE};
+
+  uint8_t pixels[1 * 4] = {0u, 255u, 0u, 255u};
+  glTexImage2D(GL_TEXTURE_2D, 0, format_type.internal_format, 1, 1, 0,
+               format_type.format, format_type.type, pixels);
+  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+
+  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+                         textures_, 0);
+
+  // Only if the format is supported by FBO, supported by this extension.
+  if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
+    return;
+
+  glApplyScreenSpaceAntialiasingCHROMIUM();
+  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError())
+      << "internal_format: "
+      << gles2::GLES2Util::GetStringEnum(format_type.internal_format);
+
+  GLTestHelper::CheckPixels(0, 0, 1, 1, 0, pixels, nullptr);
+  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+}
+
+TEST_F(GLApplyScreenSpaceAntialiasingCHROMIUMES3Test,
+       InternalFormatNotSupported) {
+  if (!available_)
+    return;
+
+  FormatType format_type = {GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT};
+
+  uint32_t pixels[1 * 4] = {0u, 255u, 0u, 255u};
+  glTexImage2D(GL_TEXTURE_2D, 0, format_type.internal_format, 1, 1, 0,
+               format_type.format, format_type.type, pixels);
+  EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
+
+  glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+                         textures_, 0);
+
+  // Only if the format is supported by FBO, supported by this extension.
+  if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
+    return;
+
+  glApplyScreenSpaceAntialiasingCHROMIUM();
+  EXPECT_EQ(static_cast<GLenum>(GL_INVALID_OPERATION), glGetError())
+      << "internal_format: "
+      << gles2::GLES2Util::GetStringEnum(format_type.internal_format);
+}
+
 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) {
@@ skipping 237 matching lines @@
   EXPECT_TRUE(GLTestHelper::CheckPixels(0, 0, 1, 1, 0, expected, nullptr));
 
   EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
 
   gl2.MakeCurrent();
   gl2.Destroy();
   gl_.MakeCurrent();
 }
 
 }  // namespace gpu