gpu: Support ES3 msaa and depth/stencil formats

gpu/command_buffer/service/feature_info_unittest.cc

 // Copyright (c) 2012 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.
 
 #include "gpu/command_buffer/service/feature_info.h"
 
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
@@ skipping 14 matching lines @@
 using ::testing::Pointee;
 using ::testing::Return;
 using ::testing::SetArrayArgument;
 using ::testing::SetArgumentPointee;
 using ::testing::StrEq;
 using ::testing::StrictMock;
 
 namespace gpu {
 namespace gles2 {
 
+namespace {
+const char kGLRendererStringANGLE[] = "ANGLE (some renderer)";
+}  // anonymous namespace
+
 class FeatureInfoTest : public testing::Test {
  public:
   FeatureInfoTest() {
   }
 
   void SetupInitExpectations(const char* extensions) {
-    SetupInitExpectationsWithGLVersion(extensions, "");
+    SetupInitExpectationsWithGLVersion(extensions, "", "");
   }
 
   void SetupInitExpectationsWithGLVersion(
-      const char* extensions, const char* version) {
+      const char* extensions, const char* renderer, const char* version) {
     TestHelper::SetupFeatureInfoInitExpectationsWithGLVersion(
-        gl_.get(), extensions, version);
+        gl_.get(), extensions, renderer, version);
     info_ = new FeatureInfo();
     info_->Initialize();
   }
 
   void SetupWithCommandLine(const CommandLine& command_line) {
     info_ = new FeatureInfo(command_line);
   }
 
   void SetupInitExpectationsWithCommandLine(
       const char* extensions, const CommandLine& command_line) {
     TestHelper::SetupFeatureInfoInitExpectationsWithGLVersion(
-        gl_.get(), extensions, "");
+        gl_.get(), extensions, "", "");
     info_ = new FeatureInfo(command_line);
     info_->Initialize();
   }
 
   void SetupWithoutInit() {
     info_ = new FeatureInfo();
   }
 
  protected:
   virtual void SetUp() {
@@ skipping 18 matching lines @@
    const GLenum* types;
    size_t count;
 };
 
 }  // anonymous namespace.
 
 TEST_F(FeatureInfoTest, Basic) {
   SetupWithoutInit();
   // Test it starts off uninitialized.
   EXPECT_FALSE(info_->feature_flags().chromium_framebuffer_multisample);
+  EXPECT_FALSE(info_->feature_flags().use_core_framebuffer_multisample);
   EXPECT_FALSE(info_->feature_flags().multisampled_render_to_texture);
   EXPECT_FALSE(info_->feature_flags(
       ).use_img_for_multisampled_render_to_texture);
   EXPECT_FALSE(info_->feature_flags().oes_standard_derivatives);
   EXPECT_FALSE(info_->feature_flags().npot_ok);
   EXPECT_FALSE(info_->feature_flags().enable_texture_float_linear);
   EXPECT_FALSE(info_->feature_flags().enable_texture_half_float_linear);
   EXPECT_FALSE(info_->feature_flags().oes_egl_image_external);
+  EXPECT_FALSE(info_->feature_flags().oes_depth24);
+  EXPECT_FALSE(info_->feature_flags().packed_depth24_stencil8);
   EXPECT_FALSE(info_->feature_flags().chromium_stream_texture);
   EXPECT_FALSE(info_->feature_flags().angle_translated_shader_source);
   EXPECT_FALSE(info_->feature_flags().angle_pack_reverse_row_order);
   EXPECT_FALSE(info_->feature_flags().arb_texture_rectangle);
   EXPECT_FALSE(info_->feature_flags().angle_instanced_arrays);
   EXPECT_FALSE(info_->feature_flags().occlusion_query_boolean);
   EXPECT_FALSE(info_->feature_flags(
       ).use_arb_occlusion_query2_for_occlusion_query_boolean);
   EXPECT_FALSE(info_->feature_flags(
       ).use_arb_occlusion_query_for_occlusion_query_boolean);
   EXPECT_FALSE(info_->feature_flags().native_vertex_array_object);
   EXPECT_FALSE(info_->feature_flags().map_buffer_range);
   EXPECT_FALSE(info_->feature_flags().use_async_readpixels);
   EXPECT_FALSE(info_->feature_flags().ext_discard_framebuffer);
   EXPECT_FALSE(info_->feature_flags().angle_depth_texture);
+  EXPECT_FALSE(info_->feature_flags().is_angle);
 
 #define GPU_OP(type, name) EXPECT_FALSE(info_->workarounds().name);
   GPU_DRIVER_BUG_WORKAROUNDS(GPU_OP)
 #undef GPU_OP
   EXPECT_EQ(0, info_->workarounds().max_texture_size);
   EXPECT_EQ(0, info_->workarounds().max_cube_map_texture_size);
 
   // Test good types.
   {
     static const GLenum kAlphaTypes[] = {
@@ skipping 151 matching lines @@
   EXPECT_FALSE(info_->validators()->texture_parameter.IsValid(
       GL_TEXTURE_USAGE_ANGLE));
   EXPECT_FALSE(info_->validators()->texture_internal_format_storage.IsValid(
       GL_DEPTH_COMPONENT16));
   EXPECT_FALSE(info_->validators()->texture_internal_format_storage.IsValid(
       GL_DEPTH_COMPONENT32_OES));
   EXPECT_FALSE(info_->validators()->texture_internal_format_storage.IsValid(
       GL_DEPTH24_STENCIL8_OES));
 }
 
+TEST_F(FeatureInfoTest, InitializeWithANGLE) {
+  SetupInitExpectationsWithGLVersion("", kGLRendererStringANGLE, "");
+  EXPECT_TRUE(info_->feature_flags().is_angle);
+}
+
 TEST_F(FeatureInfoTest, InitializeNPOTExtensionGLES) {
   SetupInitExpectations("GL_OES_texture_npot");
   EXPECT_THAT(info_->extensions(), HasSubstr("GL_OES_texture_npot"));
   EXPECT_TRUE(info_->feature_flags().npot_ok);
 }
 
 TEST_F(FeatureInfoTest, InitializeNPOTExtensionGL) {
   SetupInitExpectations("GL_ARB_texture_non_power_of_two");
   EXPECT_THAT(info_->extensions(), HasSubstr("GL_OES_texture_npot"));
   EXPECT_TRUE(info_->feature_flags().npot_ok);
@@ skipping 239 matching lines @@
   EXPECT_TRUE(info_->validators()->frame_buffer_target.IsValid(
       GL_DRAW_FRAMEBUFFER_EXT));
   EXPECT_TRUE(info_->validators()->g_l_state.IsValid(
       GL_READ_FRAMEBUFFER_BINDING_EXT));
   EXPECT_TRUE(info_->validators()->g_l_state.IsValid(
       GL_MAX_SAMPLES_EXT));
   EXPECT_TRUE(info_->validators()->render_buffer_parameter.IsValid(
       GL_RENDERBUFFER_SAMPLES_EXT));
 }
 
+TEST_F(FeatureInfoTest, InitializeANGLE_framebuffer_multisample) {
+  SetupInitExpectationsWithGLVersion(
+      "GL_ANGLE_framebuffer_multisample", kGLRendererStringANGLE, "");
+  EXPECT_TRUE(info_->feature_flags().chromium_framebuffer_multisample);
+  EXPECT_THAT(info_->extensions(),
+              HasSubstr("GL_CHROMIUM_framebuffer_multisample"));
+  EXPECT_TRUE(info_->validators()->frame_buffer_target.IsValid(
+      GL_READ_FRAMEBUFFER_EXT));
+  EXPECT_TRUE(info_->validators()->frame_buffer_target.IsValid(
+      GL_DRAW_FRAMEBUFFER_EXT));
+  EXPECT_TRUE(info_->validators()->g_l_state.IsValid(
+      GL_READ_FRAMEBUFFER_BINDING_EXT));
+  EXPECT_TRUE(info_->validators()->g_l_state.IsValid(
+      GL_MAX_SAMPLES_EXT));
+  EXPECT_TRUE(info_->validators()->render_buffer_parameter.IsValid(
+      GL_RENDERBUFFER_SAMPLES_EXT));
+}
+
+// We don't allow ANGLE_framebuffer_multisample on non-ANGLE implementations,
+// because we wouldn't be choosing the right driver entry point and because the
+// extension was falsely advertised on some Android devices (crbug.com/165736).
+TEST_F(FeatureInfoTest, InitializeANGLE_framebuffer_multisampleWithoutANGLE) {
+  SetupInitExpectations("GL_ANGLE_framebuffer_multisample");
+  EXPECT_FALSE(info_->feature_flags().chromium_framebuffer_multisample);
+  EXPECT_THAT(info_->extensions(),
+              Not(HasSubstr("GL_CHROMIUM_framebuffer_multisample")));
+  EXPECT_FALSE(info_->validators()->frame_buffer_target.IsValid(
+      GL_READ_FRAMEBUFFER_EXT));
+  EXPECT_FALSE(info_->validators()->frame_buffer_target.IsValid(
+      GL_DRAW_FRAMEBUFFER_EXT));
+  EXPECT_FALSE(info_->validators()->g_l_state.IsValid(
+      GL_READ_FRAMEBUFFER_BINDING_EXT));
+  EXPECT_FALSE(info_->validators()->g_l_state.IsValid(
+      GL_MAX_SAMPLES_EXT));
+  EXPECT_FALSE(info_->validators()->render_buffer_parameter.IsValid(
+      GL_RENDERBUFFER_SAMPLES_EXT));
+}
+
 TEST_F(FeatureInfoTest, InitializeEXT_multisampled_render_to_texture) {
   SetupInitExpectations("GL_EXT_multisampled_render_to_texture");
   EXPECT_TRUE(info_->feature_flags(
       ).multisampled_render_to_texture);
   EXPECT_FALSE(info_->feature_flags(
       ).use_img_for_multisampled_render_to_texture);
   EXPECT_THAT(info_->extensions(),
               HasSubstr("GL_EXT_multisampled_render_to_texture"));
   EXPECT_TRUE(info_->validators()->g_l_state.IsValid(
       GL_MAX_SAMPLES_EXT));
@@ skipping 140 matching lines @@
   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_DEPTH_COMPONENT).IsValid(
       GL_UNSIGNED_SHORT));
   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_DEPTH_COMPONENT).IsValid(
       GL_UNSIGNED_INT));
   EXPECT_TRUE(info_->GetTextureFormatValidator(GL_DEPTH_STENCIL).IsValid(
       GL_UNSIGNED_INT_24_8));
 }
 
 TEST_F(FeatureInfoTest, InitializeOES_depth24) {
   SetupInitExpectations("GL_OES_depth24");
+  EXPECT_TRUE(info_->feature_flags().oes_depth24);
   EXPECT_THAT(info_->extensions(), HasSubstr("GL_OES_depth24"));
   EXPECT_TRUE(info_->validators()->render_buffer_format.IsValid(
       GL_DEPTH_COMPONENT24));
 }
 
 TEST_F(FeatureInfoTest, InitializeOES_standard_derivatives) {
   SetupInitExpectations("GL_OES_standard_derivatives");
   EXPECT_THAT(info_->extensions(), HasSubstr("GL_OES_standard_derivatives"));
   EXPECT_TRUE(info_->feature_flags().oes_standard_derivatives);
   EXPECT_TRUE(info_->validators()->hint_target.IsValid(
@@ skipping 132 matching lines @@
   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_frag_depth"));
 }
 
 TEST_F(FeatureInfoTest, InitializeEXT_discard_framebuffer) {
   SetupInitExpectations("GL_EXT_discard_framebuffer");
   EXPECT_TRUE(info_->feature_flags().ext_discard_framebuffer);
   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_discard_framebuffer"));
 }
 
 TEST_F(FeatureInfoTest, InitializeSamplersWithARBSamplerObjects) {
-  SetupInitExpectationsWithGLVersion("GL_ARB_sampler_objects", "OpenGL 3.0");
+  SetupInitExpectationsWithGLVersion(
+      "GL_ARB_sampler_objects", "", "OpenGL 3.0");
   EXPECT_TRUE(info_->feature_flags().enable_samplers);
 }
 
 TEST_F(FeatureInfoTest, InitializeWithES3) {
-  SetupInitExpectationsWithGLVersion("", "OpenGL ES 3.0");
+  SetupInitExpectationsWithGLVersion("", "", "OpenGL ES 3.0");
   EXPECT_TRUE(info_->feature_flags().enable_samplers);
   EXPECT_TRUE(info_->feature_flags().map_buffer_range);
   EXPECT_TRUE(info_->feature_flags().ext_discard_framebuffer);
   EXPECT_THAT(info_->extensions(), HasSubstr("GL_EXT_discard_framebuffer"));
+  EXPECT_TRUE(info_->feature_flags().chromium_framebuffer_multisample);
+  EXPECT_TRUE(info_->feature_flags().use_core_framebuffer_multisample);
+  EXPECT_THAT(info_->extensions(),
+              HasSubstr("GL_CHROMIUM_framebuffer_multisample"));
   EXPECT_FALSE(info_->feature_flags().use_async_readpixels);
+  EXPECT_TRUE(info_->feature_flags().oes_depth24);
+  EXPECT_THAT(info_->extensions(), HasSubstr("GL_GOOGLE_depth_texture"));
+  EXPECT_THAT(info_->extensions(), HasSubstr("GL_CHROMIUM_depth_texture"));
+  EXPECT_TRUE(info_->validators()->pixel_type.IsValid(GL_UNSIGNED_INT_24_8));
+  EXPECT_TRUE(info_->GetTextureFormatValidator(GL_DEPTH_COMPONENT)
+                  .IsValid(GL_UNSIGNED_SHORT));
+  EXPECT_TRUE(info_->GetTextureFormatValidator(GL_DEPTH_COMPONENT)
+                  .IsValid(GL_UNSIGNED_INT));
+  EXPECT_TRUE(info_->GetTextureFormatValidator(GL_DEPTH_STENCIL)
+                  .IsValid(GL_UNSIGNED_INT_24_8));
+  EXPECT_TRUE(info_->feature_flags().packed_depth24_stencil8);
+  EXPECT_THAT(info_->extensions(), HasSubstr("GL_OES_depth24"));
+  EXPECT_TRUE(
+      info_->validators()->render_buffer_format.IsValid(GL_DEPTH_COMPONENT24));
+  EXPECT_TRUE(
+      info_->validators()->render_buffer_format.IsValid(GL_DEPTH24_STENCIL8));
+  EXPECT_TRUE(
+      info_->validators()->texture_internal_format.IsValid(GL_DEPTH_STENCIL));
+  EXPECT_TRUE(info_->validators()->texture_format.IsValid(GL_DEPTH_STENCIL));
 }
 
 TEST_F(FeatureInfoTest, InitializeWithoutSamplers) {
-  SetupInitExpectationsWithGLVersion("", "OpenGL GL 3.0");
+  SetupInitExpectationsWithGLVersion("", "", "OpenGL GL 3.0");
   EXPECT_FALSE(info_->feature_flags().enable_samplers);
 }
 
 TEST_F(FeatureInfoTest, InitializeWithES3AndFences) {
-  SetupInitExpectationsWithGLVersion("EGL_KHR_fence_sync", "OpenGL ES 3.0");
+  SetupInitExpectationsWithGLVersion("EGL_KHR_fence_sync", "", "OpenGL ES 3.0");
   EXPECT_TRUE(info_->feature_flags().use_async_readpixels);
 }
 
 TEST_F(FeatureInfoTest, ParseDriverBugWorkaroundsSingle) {
   CommandLine command_line(0, NULL);
   command_line.AppendSwitchASCII(
       switches::kGpuDriverBugWorkarounds,
       base::IntToString(gpu::EXIT_ON_CONTEXT_LOST));
   // Workarounds should get parsed without the need for a context.
   SetupWithCommandLine(command_line);
   EXPECT_TRUE(info_->workarounds().exit_on_context_lost);
 }
 
 TEST_F(FeatureInfoTest, ParseDriverBugWorkaroundsMultiple) {
   CommandLine command_line(0, NULL);
   command_line.AppendSwitchASCII(
       switches::kGpuDriverBugWorkarounds,
       base::IntToString(gpu::EXIT_ON_CONTEXT_LOST) + "," +
       base::IntToString(gpu::MAX_CUBE_MAP_TEXTURE_SIZE_LIMIT_1024) + "," +
       base::IntToString(gpu::MAX_TEXTURE_SIZE_LIMIT_4096));
   // Workarounds should get parsed without the need for a context.
   SetupWithCommandLine(command_line);
   EXPECT_TRUE(info_->workarounds().exit_on_context_lost);
   EXPECT_EQ(1024, info_->workarounds().max_cube_map_texture_size);
   EXPECT_EQ(4096, info_->workarounds().max_texture_size);
 }
 
 }  // namespace gles2
 }  // namespace gpu